/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_depthwise_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/depthwise_conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using ForwardWindow3Stride2 =
    sycldnn::depthwise_conv2d::WindowStrideTest<Pair, 3, 2>;
TYPED_TEST_SUITE(ForwardWindow3Stride2, GTestTypePairs);
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {128., 241., 184., 441., 681.,
                                         453., 320., 457., 280.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 501., 861., 951.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {240., 256., 449.,  482.,  340., 368.,
                                         813., 882., 1245., 1362., 819., 906.,
                                         564., 640., 791.,  914.,  472., 560.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {759.,  822.,  921.,  1002.,
                                         1569., 1722., 1731., 1902.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      464.,  480.,  496.,  512.,  865.,  898.,  931.,  964.,  652.,
      680.,  708.,  736.,  1557., 1626., 1695., 1764., 2373., 2490.,
      2607., 2724., 1551., 1638., 1725., 1812., 1052., 1128., 1204.,
      1280., 1459., 1582., 1705., 1828., 856.,  944.,  1032., 1120.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1761., 1842., 1923., 2004.,
      2985., 3138., 3291., 3444., 3291., 3462., 3633., 3804.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      428.,  512.,  826.,  964.,  636.,  736.,  1566., 1764., 2409.,
      2724., 1590., 1812., 1100., 1280., 1546., 1828., 924.,  1120.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1437., 1644., 1761., 2004.,
                                         3057., 3444., 3381., 3804.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      828.,  856.,  992.,  1024., 1592., 1652., 1862., 1928., 1220.,
      1272., 1416., 1472., 3000., 3132., 3390., 3528., 4593., 4818.,
      5214., 5448., 3012., 3180., 3450., 3624., 2052., 2200., 2408.,
      2560., 2852., 3092., 3410., 3656., 1676., 1848., 2064., 2240.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2757., 2874., 3162., 3288., 3369., 3522., 3846., 4008.,
      5817., 6114., 6582., 6888., 6429., 6762., 7266., 7608.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1628.,  1656.,  1684.,  1712.,  1952., 1984., 2016., 2048., 3124.,
      3184.,  3244.,  3304.,  3658.,  3724., 3790., 3856., 2388., 2440.,
      2492.,  2544.,  2776.,  2832.,  2888., 2944., 5868., 6000., 6132.,
      6264.,  6642.,  6780.,  6918.,  7056., 8961., 9186., 9411., 9636.,
      10194., 10428., 10662., 10896., 5856., 6024., 6192., 6360., 6726.,
      6900.,  7074.,  7248.,  3956.,  4104., 4252., 4400., 4664., 4816.,
      4968.,  5120.,  5464.,  5704.,  5944., 6184., 6574., 6820., 7066.,
      7312.,  3180.,  3352.,  3524.,  3696., 3952., 4128., 4304., 4480.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5397.,  5514.,  5631.,  5748.,  6198.,  6324.,  6450.,  6576.,
      6585.,  6738.,  6891.,  7044.,  7530.,  7692.,  7854.,  8016.,
      11337., 11634., 11931., 12228., 12858., 13164., 13470., 13776.,
      12525., 12858., 13191., 13524., 14190., 14532., 14874., 15216.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1556.,  1712.,  1876., 2048., 3046., 3304., 3574., 3856., 2356.,
      2544.,  2740.,  2944., 5886., 6264., 6654., 7056., 9033., 9636.,
      10257., 10896., 5934., 6360., 6798., 7248., 4052., 4400., 4756.,
      5120.,  5638.,  6184., 6742., 7312., 3316., 3696., 4084., 4480.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5361.,  5748.,  6153.,  6576.,  6585.,  7044.,  7521.,  8016.,
      11481., 12228., 12993., 13776., 12705., 13524., 14361., 15216.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3060.,  3112.,  3368.,  3424.,  3692.,  3752.,  4032.,  4096.,  5978.,
      6092.,  6488.,  6608.,  7022.,  7148.,  7580.,  7712.,  4612.,  4712.,
      4984.,  5088.,  5372.,  5480.,  5776.,  5888.,  11514., 11772., 12264.,
      12528., 13038., 13308., 13836., 14112., 17625., 18066., 18822., 19272.,
      20055., 20514., 21324., 21792., 11538., 11868., 12384., 12720., 13254.,
      13596., 14148., 14496., 7812.,  8104.,  8504.,  8800.,  9212.,  9512.,
      9936.,  10240., 10802., 11276., 11888., 12368., 12998., 13484., 14132.,
      14624., 6292.,  6632.,  7048.,  7392.,  7820.,  8168.,  8608.,  8960.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10497., 10722., 11262., 11496., 12063., 12306., 12900., 13152.,
      12873., 13170., 13782., 14088., 14727., 15042., 15708., 16032.,
      22377., 22962., 23862., 24456., 25383., 25986., 26940., 27552.,
      24753., 25410., 26382., 27048., 28047., 28722., 29748., 30432.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6068.,  6120.,  6172.,  6224.,  6680.,  6736.,  6792.,  6848.,  7324.,
      7384.,  7444.,  7504.,  8000.,  8064.,  8128.,  8192.,  11842., 11956.,
      12070., 12184., 12856., 12976., 13096., 13216., 13918., 14044., 14170.,
      14296., 15028., 15160., 15292., 15424., 9124.,  9224.,  9324.,  9424.,
      9864.,  9968.,  10072., 10176., 10636., 10744., 10852., 10960., 11440.,
      11552., 11664., 11776., 22770., 23028., 23286., 23544., 24264., 24528.,
      24792., 25056., 25806., 26076., 26346., 26616., 27396., 27672., 27948.,
      28224., 34809., 35250., 35691., 36132., 37194., 37644., 38094., 38544.,
      39651., 40110., 40569., 41028., 42180., 42648., 43116., 43584., 22746.,
      23076., 23406., 23736., 24432., 24768., 25104., 25440., 26166., 26508.,
      26850., 27192., 27948., 28296., 28644., 28992., 15332., 15624., 15916.,
      16208., 16712., 17008., 17304., 17600., 18124., 18424., 18724., 19024.,
      19568., 19872., 20176., 20480., 21130., 21604., 22078., 22552., 23296.,
      23776., 24256., 24736., 25510., 25996., 26482., 26968., 27772., 28264.,
      28756., 29248., 12244., 12584., 12924., 13264., 13752., 14096., 14440.,
      14784., 15292., 15640., 15988., 16336., 16864., 17216., 17568., 17920.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20769., 20994., 21219., 21444., 22290., 22524., 22758., 22992.,
      23883., 24126., 24369., 24612., 25548., 25800., 26052., 26304.,
      25449., 25746., 26043., 26340., 27258., 27564., 27870., 28176.,
      29139., 29454., 29769., 30084., 31092., 31416., 31740., 32064.,
      44169., 44754., 45339., 45924., 47130., 47724., 48318., 48912.,
      50163., 50766., 51369., 51972., 53268., 53880., 54492., 55104.,
      48849., 49506., 50163., 50820., 52098., 52764., 53430., 54096.,
      55419., 56094., 56769., 57444., 58812., 59496., 60180., 60864.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {226., 304., 223., 744., 834.,
                                         546., 514., 556., 337.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474., 564., 1014., 1104.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      422.,  452., 566.,  608., 412.,  446., 1362., 1488., 1524.,
      1668., 987., 1092., 890., 1028., 962., 1112., 568.,  674.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {876.,  948.,  1038., 1128.,
                                         1848., 2028., 2010., 2208.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      814.,  844.,  874.,  904.,  1090., 1132., 1174., 1216., 790.,
      824.,  858.,  892.,  2598., 2724., 2850., 2976., 2904., 3048.,
      3192., 3336., 1869., 1974., 2079., 2184., 1642., 1780., 1918.,
      2056., 1774., 1924., 2074., 2224., 1030., 1136., 1242., 1348.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1986., 2076., 2166., 2256.,
      3516., 3696., 3876., 4056., 3822., 4020., 4218., 4416.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      772.,  904.,  1060., 1216., 780.,  892.,  2643., 2976., 2967.,
      3336., 1926., 2184., 1744., 2056., 1888., 2224., 1116., 1348.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1671., 1896., 1995., 2256.,
                                         3615., 4056., 3939., 4416.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1490., 1544., 1748., 1808., 2042., 2120., 2348., 2432., 1496.,
      1560., 1716., 1784., 5043., 5286., 5700., 5952., 5655., 5934.,
      6384., 6672., 3648., 3852., 4158., 4368., 3218., 3488., 3836.,
      4112., 3482., 3776., 4148., 4448., 2024., 2232., 2484., 2696.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207., 3342., 3648., 3792., 3819., 3990., 4332., 4512.,
      6879., 7230., 7752., 8112., 7491., 7878., 8436., 8832.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2926.,  2980.,  3034.,  3088.,  3436.,  3496.,  3556.,  3616.,  4006.,
      4084.,  4162.,  4240.,  4612.,  4696.,  4780.,  4864.,  2928.,  2992.,
      3056.,  3120.,  3364.,  3432.,  3500.,  3568.,  9843.,  10086., 10329.,
      10572., 11148., 11400., 11652., 11904., 11031., 11310., 11589., 11868.,
      12480., 12768., 13056., 13344., 7092.,  7296.,  7500.,  7704.,  8106.,
      8316.,  8526.,  8736.,  6166.,  6436.,  6706.,  6976.,  7396.,  7672.,
      7948.,  8224.,  6670.,  6964.,  7258.,  7552.,  7996.,  8296.,  8596.,
      8896.,  3840.,  4048.,  4256.,  4464.,  4756.,  4968.,  5180.,  5392.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6279.,  6414.,  6549.,  6684.,  7152.,  7296.,  7440.,  7584.,
      7467.,  7638.,  7809.,  7980.,  8484.,  8664.,  8844.,  9024.,
      13407., 13758., 14109., 14460., 15144., 15504., 15864., 16224.,
      14595., 14982., 15369., 15756., 16476., 16872., 17268., 17664.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2842.,  3088.,  3346., 3616., 3946.,  4240.,  4546.,  4864.,  2908.,
      3120.,  3340.,  3568., 9933., 10572., 11229., 11904., 11157., 11868.,
      12597., 13344., 7206., 7704., 8214.,  8736.,  6370.,  6976.,  7594.,
      8224.,  6898.,  7552., 8218., 8896.,  4012.,  4464.,  4924.,  5392.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261.,  6684.,  7125.,  7584.,  7485.,  7980.,  8493.,  9024.,
      13605., 14460., 15333., 16224., 14829., 15756., 16701., 17664.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5582.,  5684.,  6068.,  6176.,  6578.,  6692.,  7112.,  7232.,  7742.,
      7892.,  8324.,  8480.,  8930.,  9092.,  9560.,  9728.,  5692.,  5816.,
      6112.,  6240.,  6548.,  6680.,  7000.,  7136.,  19389., 19866., 20658.,
      21144., 21963., 22458., 23304., 23808., 21765., 22314., 23178., 23736.,
      24627., 25194., 26112., 26688., 14010., 14412., 15000., 15408., 16014.,
      16428., 17052., 17472., 12206., 12740., 13412., 13952., 14642., 15188.,
      15896., 16448., 13214., 13796., 14516., 15104., 15842., 16436., 17192.,
      17792., 7612.,  8024.,  8512.,  8928.,  9428.,  9848.,  10360., 10784.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261., 12522., 13098., 13368., 13971., 14250., 14880., 15168.,
      14637., 14970., 15618., 15960., 16635., 16986., 17688., 18048.,
      26517., 27210., 28218., 28920., 29955., 30666., 31728., 32448.,
      28893., 29658., 30738., 31512., 32619., 33402., 34536., 35328.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11062., 11164., 11266., 11368., 12028., 12136., 12244., 12352., 13042.,
      13156., 13270., 13384., 14104., 14224., 14344., 14464., 15334., 15484.,
      15634., 15784., 16492., 16648., 16804., 16960., 17698., 17860., 18022.,
      18184., 18952., 19120., 19288., 19456., 11260., 11384., 11508., 11632.,
      12096., 12224., 12352., 12480., 12964., 13096., 13228., 13360., 13864.,
      14000., 14136., 14272., 38301., 38778., 39255., 39732., 40830., 41316.,
      41802., 42288., 43431., 43926., 44421., 44916., 46104., 46608., 47112.,
      47616., 42981., 43530., 44079., 44628., 45798., 46356., 46914., 47472.,
      48687., 49254., 49821., 50388., 51648., 52224., 52800., 53376., 27618.,
      28020., 28422., 28824., 29592., 30000., 30408., 30816., 31614., 32028.,
      32442., 32856., 33684., 34104., 34524., 34944., 23878., 24412., 24946.,
      25480., 26284., 26824., 27364., 27904., 28738., 29284., 29830., 30376.,
      31240., 31792., 32344., 32896., 25846., 26428., 27010., 27592., 28444.,
      29032., 29620., 30208., 31090., 31684., 32278., 32872., 33784., 34384.,
      34984., 35584., 14812., 15224., 15636., 16048., 16608., 17024., 17440.,
      17856., 18436., 18856., 19276., 19696., 20296., 20720., 21144., 21568.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24261., 24522., 24783., 25044., 25926., 26196., 26466., 26736.,
      27663., 27942., 28221., 28500., 29472., 29760., 30048., 30336.,
      28941., 29274., 29607., 29940., 30894., 31236., 31578., 31920.,
      32919., 33270., 33621., 33972., 35016., 35376., 35736., 36096.,
      52341., 53034., 53727., 54420., 55734., 56436., 57138., 57840.,
      59199., 59910., 60621., 61332., 62736., 63456., 64176., 64896.,
      57021., 57786., 58551., 59316., 60702., 61476., 62250., 63024.,
      64455., 65238., 66021., 66804., 68280., 69072., 69864., 70656.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {274.,  352., 430., 301., 960., 1050.,
                                         1140., 732., 670., 712., 754., 451.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {600., 690., 780., 1320., 1410., 1500.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      512.,  548.,  656.,  704.,  800.,  860.,  556.,  602.,
      1758., 1920., 1920., 2100., 2082., 2280., 1323., 1464.,
      1160., 1340., 1232., 1424., 1304., 1508., 760.,  902.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1110., 1200., 1272., 1380.,
                                         1434., 1560., 2406., 2640.,
                                         2568., 2820., 2730., 3000.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      988.,  1024., 1060., 1096., 1264., 1312., 1360., 1408., 1540., 1600.,
      1660., 1720., 1066., 1112., 1158., 1204., 3354., 3516., 3678., 3840.,
      3660., 3840., 4020., 4200., 3966., 4164., 4362., 4560., 2505., 2646.,
      2787., 2928., 2140., 2320., 2500., 2680., 2272., 2464., 2656., 2848.,
      2404., 2608., 2812., 3016., 1378., 1520., 1662., 1804.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130., 2220., 2310., 2400., 2436., 2544., 2652., 2760.,
      2742., 2868., 2994., 3120., 4578., 4812., 5046., 5280.,
      4884., 5136., 5388., 5640., 5190., 5460., 5730., 6000.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      952.,  1096., 1240., 1408., 1528., 1720., 1068., 1204.,
      3435., 3840., 3759., 4200., 4083., 4560., 2598., 2928.,
      2284., 2680., 2428., 2848., 2572., 3016., 1500., 1804.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2139., 2400., 2463., 2760.,
                                         2787., 3120., 4731., 5280.,
                                         5055., 5640., 5379., 6000.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1838., 1904., 2120., 2192., 2390., 2480., 2720., 2816., 2942., 3056.,
      3320., 3440., 2048., 2136., 2316., 2408., 6555., 6870., 7356., 7680.,
      7167., 7518., 8040., 8400., 7779., 8166., 8724., 9120., 4920., 5196.,
      5574., 5856., 4214., 4568., 5000., 5360., 4478., 4856., 5312., 5696.,
      4742., 5144., 5624., 6032., 2720., 3000., 3324., 3608.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107., 4278.,  4620.,  4800.,  4719.,  4926.,  5304.,  5520.,
      5331., 5574.,  5988.,  6240.,  9003.,  9462.,  10092., 10560.,
      9615., 10110., 10776., 11280., 10227., 10758., 11460., 12000.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3610.,  3676.,  3742.,  3808.,  4168.,  4240.,  4312.,  4384.,  4690.,
      4780.,  4870.,  4960.,  5344.,  5440.,  5536.,  5632.,  5770.,  5884.,
      5998.,  6112.,  6520.,  6640.,  6760.,  6880.,  4008.,  4096.,  4184.,
      4272.,  4540.,  4632.,  4724.,  4816.,  12795., 13110., 13425., 13740.,
      14388., 14712., 15036., 15360., 13983., 14334., 14685., 15036., 15720.,
      16080., 16440., 16800., 15171., 15558., 15945., 16332., 17052., 17448.,
      17844., 18240., 9564.,  9840.,  10116., 10392., 10866., 11148., 11430.,
      11712., 8074.,  8428.,  8782.,  9136.,  9640.,  10000., 10360., 10720.,
      8578.,  8956.,  9334.,  9712.,  10240., 10624., 11008., 11392., 9082.,
      9484.,  9886.,  10288., 10840., 11248., 11656., 12064., 5160.,  5440.,
      5720.,  6000.,  6364.,  6648.,  6932.,  7216.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8043.,  8214.,  8385.,  8556.,  9060.,  9240.,  9420.,  9600.,
      9231.,  9438.,  9645.,  9852.,  10392., 10608., 10824., 11040.,
      10419., 10662., 10905., 11148., 11724., 11976., 12228., 12480.,
      17547., 18006., 18465., 18924., 19716., 20184., 20652., 21120.,
      18735., 19230., 19725., 20220., 21048., 21552., 22056., 22560.,
      19923., 20454., 20985., 21516., 22380., 22920., 23460., 24000.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3538.,  3808.,  4090.,  4384.,  4642.,  4960.,  5290.,  5632.,
      5746.,  6112.,  6490.,  6880.,  4012.,  4272.,  4540.,  4816.,
      12957., 13740., 14541., 15360., 14181., 15036., 15909., 16800.,
      15405., 16332., 17277., 18240., 9750.,  10392., 11046., 11712.,
      8362.,  9136.,  9922.,  10720., 8890.,  9712.,  10546., 11392.,
      9418.,  10288., 11170., 12064., 5404.,  6000.,  6604.,  7216.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,  8556.,  9069.,  9600.,  9285.,  9852.,  10437., 11040.,
      10509., 11148., 11805., 12480., 17853., 18924., 20013., 21120.,
      19077., 20220., 21381., 22560., 20301., 21516., 22749., 24000.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6950.,  7076.,  7484.,  7616.,  8042.,  8180.,  8624.,  8768.,  9110.,
      9284.,  9740.,  9920.,  10394., 10580., 11072., 11264., 11270., 11492.,
      11996., 12224., 12746., 12980., 13520., 13760., 7852.,  8024.,  8368.,
      8544.,  8900.,  9080.,  9448.,  9632.,  25293., 25914., 26850., 27480.,
      28443., 29082., 30072., 30720., 27669., 28362., 29370., 30072., 31107.,
      31818., 32880., 33600., 30045., 30810., 31890., 32664., 33771., 34554.,
      35688., 36480., 18954., 19500., 20232., 20784., 21534., 22092., 22860.,
      23424., 16022., 16724., 17564., 18272., 19130., 19844., 20720., 21440.,
      17030., 17780., 18668., 19424., 20330., 21092., 22016., 22784., 18038.,
      18836., 19772., 20576., 21530., 22340., 23312., 24128., 10252., 10808.,
      11440., 12000., 12644., 13208., 13864., 14432.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789., 16122., 16770., 17112., 17787., 18138., 18840., 19200.,
      18165., 18570., 19290., 19704., 20451., 20874., 21648., 22080.,
      20541., 21018., 21810., 22296., 23115., 23610., 24456., 24960.,
      34797., 35706., 36930., 37848., 39099., 40026., 41304., 42240.,
      37173., 38154., 39450., 40440., 41763., 42762., 44112., 45120.,
      39549., 40602., 41970., 43032., 44427., 45498., 46920., 48000.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13774., 13900., 14026., 14152., 14836., 14968., 15100., 15232., 15946.,
      16084., 16222., 16360., 17104., 17248., 17392., 17536., 18046., 18220.,
      18394., 18568., 19300., 19480., 19660., 19840., 20602., 20788., 20974.,
      21160., 21952., 22144., 22336., 22528., 22318., 22540., 22762., 22984.,
      23764., 23992., 24220., 24448., 25258., 25492., 25726., 25960., 26800.,
      27040., 27280., 27520., 15532., 15704., 15876., 16048., 16560., 16736.,
      16912., 17088., 17620., 17800., 17980., 18160., 18712., 18896., 19080.,
      19264., 49965., 50586., 51207., 51828., 53070., 53700., 54330., 54960.,
      56247., 56886., 57525., 58164., 59496., 60144., 60792., 61440., 54645.,
      55338., 56031., 56724., 58038., 58740., 59442., 60144., 61503., 62214.,
      62925., 63636., 65040., 65760., 66480., 67200., 59325., 60090., 60855.,
      61620., 63006., 63780., 64554., 65328., 66759., 67542., 68325., 69108.,
      70584., 71376., 72168., 72960., 37362., 37908., 38454., 39000., 39912.,
      40464., 41016., 41568., 42510., 43068., 43626., 44184., 45156., 45720.,
      46284., 46848., 31342., 32044., 32746., 33448., 34420., 35128., 35836.,
      36544., 37546., 38260., 38974., 39688., 40720., 41440., 42160., 42880.,
      33310., 34060., 34810., 35560., 36580., 37336., 38092., 38848., 39898.,
      40660., 41422., 42184., 43264., 44032., 44800., 45568., 35278., 36076.,
      36874., 37672., 38740., 39544., 40348., 41152., 42250., 43060., 43870.,
      44680., 45808., 46624., 47440., 48256., 19948., 20504., 21060., 21616.,
      22320., 22880., 23440., 24000., 24724., 25288., 25852., 26416., 27160.,
      27728., 28296., 28864.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31245., 31578., 31911., 32244., 33198., 33540., 33882., 34224., 35223.,
      35574., 35925., 36276., 37320., 37680., 38040., 38400., 35925., 36330.,
      36735., 37140., 38166., 38580., 38994., 39408., 40479., 40902., 41325.,
      41748., 42864., 43296., 43728., 44160., 40605., 41082., 41559., 42036.,
      43134., 43620., 44106., 44592., 45735., 46230., 46725., 47220., 48408.,
      48912., 49416., 49920., 68685., 69594., 70503., 71412., 72942., 73860.,
      74778., 75696., 77271., 78198., 79125., 80052., 81672., 82608., 83544.,
      84480., 73365., 74346., 75327., 76308., 77910., 78900., 79890., 80880.,
      82527., 83526., 84525., 85524., 87216., 88224., 89232., 90240., 78045.,
      79098., 80151., 81204., 82878., 83940., 85002., 86064., 87783., 88854.,
      89925., 90996., 92760., 93840., 94920., 96000.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {276., 456., 318., 606., 906.,
                                         588., 400., 562., 340.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 501., 861., 951.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      513.,  552.,  840.,  912., 579., 636., 1113., 1212., 1650.,
      1812., 1059., 1176., 704., 800., 971., 1124., 572.,  680.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {759.,  822.,  921.,  1002.,
                                         1569., 1722., 1731., 1902.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      987.,  1026., 1065., 1104., 1608., 1680., 1752., 1824., 1101.,
      1158., 1215., 1272., 2127., 2226., 2325., 2424., 3138., 3300.,
      3462., 3624., 2001., 2118., 2235., 2352., 1312., 1408., 1504.,
      1600., 1789., 1942., 2095., 2248., 1036., 1144., 1252., 1360.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1761., 1842., 1923., 2004.,
      2985., 3138., 3291., 3444., 3291., 3462., 3633., 3804.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      966.,  1104., 1599., 1824., 1110., 1272., 2166., 2424., 3219.,
      3624., 2070., 2352., 1380., 1600., 1906., 2248., 1124., 1360.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1437., 1644., 1761., 2004.,
                                         3057., 3444., 3381., 3804.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1860., 1932., 2130., 2208., 3063., 3198., 3504., 3648., 2112.,
      2220., 2430., 2544., 4140., 4332., 4650., 4848., 6123., 6438.,
      6924., 7248., 3912., 4140., 4470., 4704., 2572., 2760., 3008.,
      3200., 3512., 3812., 4190., 4496., 2036., 2248., 2504., 2720.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2757., 2874., 3162., 3288., 3369., 3522., 3846., 4008.,
      5817., 6114., 6582., 6888., 6429., 6762., 7266., 7608.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3648.,  3720.,  3792.,  3864.,  4182., 4260.,  4338.,  4416.,  5991.,
      6126.,  6261.,  6396.,  6864.,  7008., 7152.,  7296.,  4116.,  4224.,
      4332.,  4440.,  4746.,  4860.,  4974., 5088.,  8088.,  8280.,  8472.,
      8664.,  9102.,  9300.,  9498.,  9696., 11931., 12246., 12561., 12876.,
      13524., 13848., 14172., 14496., 7596., 7824.,  8052.,  8280.,  8706.,
      8940.,  9174.,  9408.,  4956.,  5144., 5332.,  5520.,  5824.,  6016.,
      6208.,  6400.,  6724.,  7024.,  7324., 7624.,  8074.,  8380.,  8686.,
      8992.,  3860.,  4072.,  4284.,  4496., 4792.,  5008.,  5224.,  5440.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5397.,  5514.,  5631.,  5748.,  6198.,  6324.,  6450.,  6576.,
      6585.,  6738.,  6891.,  7044.,  7530.,  7692.,  7854.,  8016.,
      11337., 11634., 11931., 12228., 12858., 13164., 13470., 13776.,
      12525., 12858., 13191., 13524., 14190., 14532., 14874., 15216.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3606.,  3864.,  4134., 4416., 5973., 6396., 6837., 7296.,  4134.,
      4440.,  4758.,  5088., 8166., 8664., 9174., 9696., 12093., 12876.,
      13677., 14496., 7734., 8280., 8838., 9408., 5092., 5520.,  5956.,
      6400.,  6958.,  7624., 8302., 8992., 4036., 4496., 4964.,  5440.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5361.,  5748.,  6153.,  6576.,  6585.,  7044.,  7521.,  8016.,
      11481., 12228., 12993., 13776., 12705., 13524., 14361., 15216.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7074.,  7212.,  7584.,  7728.,  8118.,  8268.,  8676.,  8832.,  11685.,
      11946., 12522., 12792., 13395., 13674., 14304., 14592., 8058.,  8268.,
      8664.,  8880.,  9294.,  9516.,  9948.,  10176., 15954., 16332., 16944.,
      17328., 17958., 18348., 18996., 19392., 23565., 24186., 25122., 25752.,
      26715., 27354., 28344., 28992., 15018., 15468., 16104., 16560., 17214.,
      17676., 18348., 18816., 9812.,  10184., 10664., 11040., 11532., 11912.,
      12416., 12800., 13322., 13916., 14648., 15248., 15998., 16604., 17372.,
      17984., 7652.,  8072.,  8568.,  8992.,  9500.,  9928.,  10448., 10880.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10497., 10722., 11262., 11496., 12063., 12306., 12900., 13152.,
      12873., 13170., 13782., 14088., 14727., 15042., 15708., 16032.,
      22377., 22962., 23862., 24456., 25383., 25986., 26940., 27552.,
      24753., 25410., 26382., 27048., 28047., 28722., 29748., 30432.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14010., 14148., 14286., 14424., 15024., 15168., 15312., 15456., 16086.,
      16236., 16386., 16536., 17196., 17352., 17508., 17664., 23109., 23370.,
      23631., 23892., 24774., 25044., 25314., 25584., 26511., 26790., 27069.,
      27348., 28320., 28608., 28896., 29184., 15906., 16116., 16326., 16536.,
      17112., 17328., 17544., 17760., 18366., 18588., 18810., 19032., 19668.,
      19896., 20124., 20352., 31530., 31908., 32286., 32664., 33504., 33888.,
      34272., 34656., 35526., 35916., 36306., 36696., 37596., 37992., 38388.,
      38784., 46509., 47130., 47751., 48372., 49614., 50244., 50874., 51504.,
      52791., 53430., 54069., 54708., 56040., 56688., 57336., 57984., 29586.,
      30036., 30486., 30936., 31752., 32208., 32664., 33120., 33966., 34428.,
      34890., 35352., 36228., 36696., 37164., 37632., 19252., 19624., 19996.,
      20368., 20952., 21328., 21704., 22080., 22684., 23064., 23444., 23824.,
      24448., 24832., 25216., 25600., 26050., 26644., 27238., 27832., 28696.,
      29296., 29896., 30496., 31390., 31996., 32602., 33208., 34132., 34744.,
      35356., 35968., 14884., 15304., 15724., 16144., 16712., 17136., 17560.,
      17984., 18572., 19000., 19428., 19856., 20464., 20896., 21328., 21760.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20769., 20994., 21219., 21444., 22290., 22524., 22758., 22992.,
      23883., 24126., 24369., 24612., 25548., 25800., 26052., 26304.,
      25449., 25746., 26043., 26340., 27258., 27564., 27870., 28176.,
      29139., 29454., 29769., 30084., 31092., 31416., 31740., 32064.,
      44169., 44754., 45339., 45924., 47130., 47724., 48318., 48912.,
      50163., 50766., 51369., 51972., 53268., 53880., 54492., 55104.,
      48849., 49506., 50163., 50820., 52098., 52764., 53430., 54096.,
      55419., 56094., 56769., 57444., 58812., 59496., 60180., 60864.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474., 564., 384., 1014., 1104.,
                                         708., 640., 682., 409.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474., 564., 1014., 1104.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038., 1128., 699.,  768.,  1848., 2028., 2010.,
      2208., 1275., 1416., 1106., 1280., 1178., 1364., 688.,  818.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {876.,  948.,  1038., 1128.,
                                         1848., 2028., 2010., 2208.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1986., 2076., 2166., 2256., 1329.,
      1398., 1467., 1536., 3516., 3696., 3876., 4056., 3822., 4020.,
      4218., 4416., 2409., 2550., 2691., 2832., 2038., 2212., 2386.,
      2560., 2170., 2356., 2542., 2728., 1246., 1376., 1506., 1636.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1986., 2076., 2166., 2256.,
      3516., 3696., 3876., 4056., 3822., 4020., 4218., 4416.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1671., 1896., 1995., 2256., 1350., 1536., 3615., 4056., 3939.,
      4416., 2502., 2832., 2176., 2560., 2320., 2728., 1356., 1636.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1671., 1896., 1995., 2256.,
                                         3615., 4056., 3939., 4416.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207., 3342., 3648., 3792., 3819., 3990., 4332., 4512., 2568.,
      2700., 2934., 3072., 6879., 7230., 7752., 8112., 7491., 7878.,
      8436., 8832., 4728., 5004., 5382., 5664., 4010., 4352., 4772.,
      5120., 4274., 4640., 5084., 5456., 2456., 2712., 3012., 3272.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207., 3342., 3648., 3792., 3819., 3990., 4332., 4512.,
      6879., 7230., 7752., 8112., 7491., 7878., 8436., 8832.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6279.,  6414.,  6549.,  6684.,  7152.,  7296.,  7440.,  7584.,  7467.,
      7638.,  7809.,  7980.,  8484.,  8664.,  8844.,  9024.,  5004.,  5136.,
      5268.,  5400.,  5730.,  5868.,  6006.,  6144.,  13407., 13758., 14109.,
      14460., 15144., 15504., 15864., 16224., 14595., 14982., 15369., 15756.,
      16476., 16872., 17268., 17664., 9180.,  9456.,  9732.,  10008., 10482.,
      10764., 11046., 11328., 7678.,  8020.,  8362.,  8704.,  9196.,  9544.,
      9892.,  10240., 8182.,  8548.,  8914.,  9280.,  9796.,  10168., 10540.,
      10912., 4656.,  4912.,  5168.,  5424.,  5764.,  6024.,  6284.,  6544.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6279.,  6414.,  6549.,  6684.,  7152.,  7296.,  7440.,  7584.,
      7467.,  7638.,  7809.,  7980.,  8484.,  8664.,  8844.,  9024.,
      13407., 13758., 14109., 14460., 15144., 15504., 15864., 16224.,
      14595., 14982., 15369., 15756., 16476., 16872., 17268., 17664.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261.,  6684.,  7125., 7584.,  7485.,  7980.,  8493.,  9024.,  5046.,
      5400.,  5766.,  6144., 13605., 14460., 15333., 16224., 14829., 15756.,
      16701., 17664., 9366., 10008., 10662., 11328., 7954.,  8704.,  9466.,
      10240., 8482.,  9280., 10090., 10912., 4876.,  5424.,  5980.,  6544.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261.,  6684.,  7125.,  7584.,  7485.,  7980.,  8493.,  9024.,
      13605., 14460., 15333., 16224., 14829., 15756., 16701., 17664.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261., 12522., 13098., 13368., 13971., 14250., 14880., 15168., 14637.,
      14970., 15618., 15960., 16635., 16986., 17688., 18048., 9834.,  10092.,
      10536., 10800., 11262., 11532., 12012., 12288., 26517., 27210., 28218.,
      28920., 29955., 30666., 31728., 32448., 28893., 29658., 30738., 31512.,
      32619., 33402., 34536., 35328., 18186., 18732., 19464., 20016., 20766.,
      21324., 22092., 22656., 15230., 15908., 16724., 17408., 18242., 18932.,
      19784., 20480., 16238., 16964., 17828., 18560., 19442., 20180., 21080.,
      21824., 9244.,  9752.,  10336., 10848., 11444., 11960., 12568., 13088.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261., 12522., 13098., 13368., 13971., 14250., 14880., 15168.,
      14637., 14970., 15618., 15960., 16635., 16986., 17688., 18048.,
      26517., 27210., 28218., 28920., 29955., 30666., 31728., 32448.,
      28893., 29658., 30738., 31512., 32619., 33402., 34536., 35328.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24261., 24522., 24783., 25044., 25926., 26196., 26466., 26736., 27663.,
      27942., 28221., 28500., 29472., 29760., 30048., 30336., 28941., 29274.,
      29607., 29940., 30894., 31236., 31578., 31920., 32919., 33270., 33621.,
      33972., 35016., 35376., 35736., 36096., 19410., 19668., 19926., 20184.,
      20808., 21072., 21336., 21600., 22254., 22524., 22794., 23064., 23748.,
      24024., 24300., 24576., 52341., 53034., 53727., 54420., 55734., 56436.,
      57138., 57840., 59199., 59910., 60621., 61332., 62736., 63456., 64176.,
      64896., 57021., 57786., 58551., 59316., 60702., 61476., 62250., 63024.,
      64455., 65238., 66021., 66804., 68280., 69072., 69864., 70656., 35826.,
      36372., 36918., 37464., 38376., 38928., 39480., 40032., 40974., 41532.,
      42090., 42648., 43620., 44184., 44748., 45312., 29782., 30460., 31138.,
      31816., 32764., 33448., 34132., 34816., 35794., 36484., 37174., 37864.,
      38872., 39568., 40264., 40960., 31750., 32476., 33202., 33928., 34924.,
      35656., 36388., 37120., 38146., 38884., 39622., 40360., 41416., 42160.,
      42904., 43648., 17980., 18488., 18996., 19504., 20160., 20672., 21184.,
      21696., 22372., 22888., 23404., 23920., 24616., 25136., 25656., 26176.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24261., 24522., 24783., 25044., 25926., 26196., 26466., 26736.,
      27663., 27942., 28221., 28500., 29472., 29760., 30048., 30336.,
      28941., 29274., 29607., 29940., 30894., 31236., 31578., 31920.,
      32919., 33270., 33621., 33972., 35016., 35376., 35736., 36096.,
      52341., 53034., 53727., 54420., 55734., 56436., 57138., 57840.,
      59199., 59910., 60621., 61332., 62736., 63456., 64176., 64896.,
      57021., 57786., 58551., 59316., 60702., 61476., 62250., 63024.,
      64455., 65238., 66021., 66804., 68280., 69072., 69864., 70656.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {600.,  690., 780., 516., 1320., 1410.,
                                         1500., 948., 838., 880., 922.,  547.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {600., 690., 780., 1320., 1410., 1500.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110., 1200., 1272., 1380., 1434., 1560., 939.,  1032.,
      2406., 2640., 2568., 2820., 2730., 3000., 1707., 1896.,
      1448., 1676., 1520., 1760., 1592., 1844., 920.,  1094.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1110., 1200., 1272., 1380.,
                                         1434., 1560., 2406., 2640.,
                                         2568., 2820., 2730., 3000.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130., 2220., 2310., 2400., 2436., 2544., 2652., 2760., 2742., 2868.,
      2994., 3120., 1785., 1878., 1971., 2064., 4578., 4812., 5046., 5280.,
      4884., 5136., 5388., 5640., 5190., 5460., 5730., 6000., 3225., 3414.,
      3603., 3792., 2668., 2896., 3124., 3352., 2800., 3040., 3280., 3520.,
      2932., 3184., 3436., 3688., 1666., 1840., 2014., 2188.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130., 2220., 2310., 2400., 2436., 2544., 2652., 2760.,
      2742., 2868., 2994., 3120., 4578., 4812., 5046., 5280.,
      4884., 5136., 5388., 5640., 5190., 5460., 5730., 6000.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2139., 2400., 2463., 2760., 2787., 3120., 1830., 2064.,
      4731., 5280., 5055., 5640., 5379., 6000., 3366., 3792.,
      2860., 3352., 3004., 3520., 3148., 3688., 1820., 2188.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2139., 2400., 2463., 2760.,
                                         2787., 3120., 4731., 5280.,
                                         5055., 5640., 5379., 6000.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107.,  4278.,  4620.,  4800.,  4719., 4926.,  5304.,  5520.,
      5331.,  5574.,  5988.,  6240.,  3480., 3660.,  3942.,  4128.,
      9003.,  9462.,  10092., 10560., 9615., 10110., 10776., 11280.,
      10227., 10758., 11460., 12000., 6360., 6732.,  7206.,  7584.,
      5270.,  5720.,  6248.,  6704.,  5534., 6008.,  6560.,  7040.,
      5798.,  6296.,  6872.,  7376.,  3296., 3640.,  4028.,  4376.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107., 4278.,  4620.,  4800.,  4719.,  4926.,  5304.,  5520.,
      5331., 5574.,  5988.,  6240.,  9003.,  9462.,  10092., 10560.,
      9615., 10110., 10776., 11280., 10227., 10758., 11460., 12000.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8043.,  8214.,  8385.,  8556.,  9060.,  9240.,  9420.,  9600.,  9231.,
      9438.,  9645.,  9852.,  10392., 10608., 10824., 11040., 10419., 10662.,
      10905., 11148., 11724., 11976., 12228., 12480., 6780.,  6960.,  7140.,
      7320.,  7698.,  7884.,  8070.,  8256.,  17547., 18006., 18465., 18924.,
      19716., 20184., 20652., 21120., 18735., 19230., 19725., 20220., 21048.,
      21552., 22056., 22560., 19923., 20454., 20985., 21516., 22380., 22920.,
      23460., 24000., 12348., 12720., 13092., 13464., 14034., 14412., 14790.,
      15168., 10090., 10540., 10990., 11440., 12040., 12496., 12952., 13408.,
      10594., 11068., 11542., 12016., 12640., 13120., 13600., 14080., 11098.,
      11596., 12094., 12592., 13240., 13744., 14248., 14752., 6248.,  6592.,
      6936.,  7280.,  7708.,  8056.,  8404.,  8752.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8043.,  8214.,  8385.,  8556.,  9060.,  9240.,  9420.,  9600.,
      9231.,  9438.,  9645.,  9852.,  10392., 10608., 10824., 11040.,
      10419., 10662., 10905., 11148., 11724., 11976., 12228., 12480.,
      17547., 18006., 18465., 18924., 19716., 20184., 20652., 21120.,
      18735., 19230., 19725., 20220., 21048., 21552., 22056., 22560.,
      19923., 20454., 20985., 21516., 22380., 22920., 23460., 24000.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,  8556.,  9069.,  9600.,  9285.,  9852.,  10437., 11040.,
      10509., 11148., 11805., 12480., 6870.,  7320.,  7782.,  8256.,
      17853., 18924., 20013., 21120., 19077., 20220., 21381., 22560.,
      20301., 21516., 22749., 24000., 12630., 13464., 14310., 15168.,
      10474., 11440., 12418., 13408., 11002., 12016., 13042., 14080.,
      11530., 12592., 13666., 14752., 6556.,  7280.,  8012.,  8752.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,  8556.,  9069.,  9600.,  9285.,  9852.,  10437., 11040.,
      10509., 11148., 11805., 12480., 17853., 18924., 20013., 21120.,
      19077., 20220., 21381., 22560., 20301., 21516., 22749., 24000.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789., 16122., 16770., 17112., 17787., 18138., 18840., 19200., 18165.,
      18570., 19290., 19704., 20451., 20874., 21648., 22080., 20541., 21018.,
      21810., 22296., 23115., 23610., 24456., 24960., 13386., 13740., 14280.,
      14640., 15198., 15564., 16140., 16512., 34797., 35706., 36930., 37848.,
      39099., 40026., 41304., 42240., 37173., 38154., 39450., 40440., 41763.,
      42762., 44112., 45120., 39549., 40602., 41970., 43032., 44427., 45498.,
      46920., 48000., 24522., 25260., 26184., 26928., 27870., 28620., 29580.,
      30336., 20054., 20948., 21980., 22880., 23930., 24836., 25904., 26816.,
      21062., 22004., 23084., 24032., 25130., 26084., 27200., 28160., 22070.,
      23060., 24188., 25184., 26330., 27332., 28496., 29504., 12428., 13112.,
      13872., 14560., 15332., 16024., 16808., 17504.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789., 16122., 16770., 17112., 17787., 18138., 18840., 19200.,
      18165., 18570., 19290., 19704., 20451., 20874., 21648., 22080.,
      20541., 21018., 21810., 22296., 23115., 23610., 24456., 24960.,
      34797., 35706., 36930., 37848., 39099., 40026., 41304., 42240.,
      37173., 38154., 39450., 40440., 41763., 42762., 44112., 45120.,
      39549., 40602., 41970., 43032., 44427., 45498., 46920., 48000.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31245., 31578., 31911., 32244., 33198., 33540., 33882., 34224., 35223.,
      35574., 35925., 36276., 37320., 37680., 38040., 38400., 35925., 36330.,
      36735., 37140., 38166., 38580., 38994., 39408., 40479., 40902., 41325.,
      41748., 42864., 43296., 43728., 44160., 40605., 41082., 41559., 42036.,
      43134., 43620., 44106., 44592., 45735., 46230., 46725., 47220., 48408.,
      48912., 49416., 49920., 26418., 26772., 27126., 27480., 28200., 28560.,
      28920., 29280., 30030., 30396., 30762., 31128., 31908., 32280., 32652.,
      33024., 68685., 69594., 70503., 71412., 72942., 73860., 74778., 75696.,
      77271., 78198., 79125., 80052., 81672., 82608., 83544., 84480., 73365.,
      74346., 75327., 76308., 77910., 78900., 79890., 80880., 82527., 83526.,
      84525., 85524., 87216., 88224., 89232., 90240., 78045., 79098., 80151.,
      81204., 82878., 83940., 85002., 86064., 87783., 88854., 89925., 90996.,
      92760., 93840., 94920., 96000., 48306., 49044., 49782., 50520., 51624.,
      52368., 53112., 53856., 54990., 55740., 56490., 57240., 58404., 59160.,
      59916., 60672., 39214., 40108., 41002., 41896., 43060., 43960., 44860.,
      45760., 46954., 47860., 48766., 49672., 50896., 51808., 52720., 53632.,
      41182., 42124., 43066., 44008., 45220., 46168., 47116., 48064., 49306.,
      50260., 51214., 52168., 53440., 54400., 55360., 56320., 43150., 44140.,
      45130., 46120., 47380., 48376., 49372., 50368., 51658., 52660., 53662.,
      54664., 55984., 56992., 58000., 59008., 24172., 24856., 25540., 26224.,
      27056., 27744., 28432., 29120., 29972., 30664., 31356., 32048., 32920.,
      33616., 34312., 35008.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31245., 31578., 31911., 32244., 33198., 33540., 33882., 34224., 35223.,
      35574., 35925., 36276., 37320., 37680., 38040., 38400., 35925., 36330.,
      36735., 37140., 38166., 38580., 38994., 39408., 40479., 40902., 41325.,
      41748., 42864., 43296., 43728., 44160., 40605., 41082., 41559., 42036.,
      43134., 43620., 44106., 44592., 45735., 46230., 46725., 47220., 48408.,
      48912., 49416., 49920., 68685., 69594., 70503., 71412., 72942., 73860.,
      74778., 75696., 77271., 78198., 79125., 80052., 81672., 82608., 83544.,
      84480., 73365., 74346., 75327., 76308., 77910., 78900., 79890., 80880.,
      82527., 83526., 84525., 85524., 87216., 88224., 89232., 90240., 78045.,
      79098., 80151., 81204., 82878., 83940., 85002., 86064., 87783., 88854.,
      89925., 90996., 92760., 93840., 94920., 96000.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {276., 456.,  318., 606., 906., 588.,
                                         936., 1356., 858., 560., 772., 460.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 501., 861., 951., 1311., 1401.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      513.,  552.,  840.,  912.,  579.,  636.,  1113., 1212.,
      1650., 1812., 1059., 1176., 1713., 1872., 2460., 2712.,
      1539., 1716., 984.,  1120., 1331., 1544., 772.,  920.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {759.,  822.,  921.,  1002.,
                                         1569., 1722., 1731., 1902.,
                                         2379., 2622., 2541., 2802.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      987.,  1026., 1065., 1104., 1608., 1680., 1752., 1824., 1101., 1158.,
      1215., 1272., 2127., 2226., 2325., 2424., 3138., 3300., 3462., 3624.,
      2001., 2118., 2235., 2352., 3267., 3426., 3585., 3744., 4668., 4920.,
      5172., 5424., 2901., 3078., 3255., 3432., 1832., 1968., 2104., 2240.,
      2449., 2662., 2875., 3088., 1396., 1544., 1692., 1840.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1761., 1842., 1923., 2004.,
      2985., 3138., 3291., 3444., 3291., 3462., 3633., 3804.,
      4515., 4758., 5001., 5244., 4821., 5082., 5343., 5604.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      966.,  1104., 1599., 1824., 1110., 1272., 2166., 2424.,
      3219., 3624., 2070., 2352., 3366., 3744., 4839., 5424.,
      3030., 3432., 1940., 2240., 2626., 3088., 1524., 1840.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1437., 1644., 1761., 2004.,
                                         3057., 3444., 3381., 3804.,
                                         4677., 5244., 5001., 5604.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1860.,  1932.,  2130., 2208., 3063., 3198., 3504., 3648., 2112., 2220.,
      2430.,  2544.,  4140., 4332., 4650., 4848., 6123., 6438., 6924., 7248.,
      3912.,  4140.,  4470., 4704., 6420., 6732., 7170., 7488., 9183., 9678.,
      10344., 10848., 5712., 6060., 6510., 6864., 3612., 3880., 4208., 4480.,
      4832.,  5252.,  5750., 6176., 2756., 3048., 3384., 3680.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2757., 2874., 3162.,  3288.,  3369., 3522.,  3846.,  4008.,
      5817., 6114., 6582.,  6888.,  6429., 6762.,  7266.,  7608.,
      8877., 9354., 10002., 10488., 9489., 10002., 10686., 11208.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3648.,  3720.,  3792.,  3864.,  4182.,  4260.,  4338.,  4416.,  5991.,
      6126.,  6261.,  6396.,  6864.,  7008.,  7152.,  7296.,  4116.,  4224.,
      4332.,  4440.,  4746.,  4860.,  4974.,  5088.,  8088.,  8280.,  8472.,
      8664.,  9102.,  9300.,  9498.,  9696.,  11931., 12246., 12561., 12876.,
      13524., 13848., 14172., 14496., 7596.,  7824.,  8052.,  8280.,  8706.,
      8940.,  9174.,  9408.,  12528., 12840., 13152., 13464., 14022., 14340.,
      14658., 14976., 17871., 18366., 18861., 19356., 20184., 20688., 21192.,
      21696., 11076., 11424., 11772., 12120., 12666., 13020., 13374., 13728.,
      6956.,  7224.,  7492.,  7760.,  8144.,  8416.,  8688.,  8960.,  9244.,
      9664.,  10084., 10504., 11074., 11500., 11926., 12352., 5220.,  5512.,
      5804.,  6096.,  6472.,  6768.,  7064.,  7360.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5397.,  5514.,  5631.,  5748.,  6198.,  6324.,  6450.,  6576.,
      6585.,  6738.,  6891.,  7044.,  7530.,  7692.,  7854.,  8016.,
      11337., 11634., 11931., 12228., 12858., 13164., 13470., 13776.,
      12525., 12858., 13191., 13524., 14190., 14532., 14874., 15216.,
      17277., 17754., 18231., 18708., 19518., 20004., 20490., 20976.,
      18465., 18978., 19491., 20004., 20850., 21372., 21894., 22416.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3606.,  3864.,  4134.,  4416.,  5973.,  6396.,  6837.,  7296.,
      4134.,  4440.,  4758.,  5088.,  8166.,  8664.,  9174.,  9696.,
      12093., 12876., 13677., 14496., 7734.,  8280.,  8838.,  9408.,
      12726., 13464., 14214., 14976., 18213., 19356., 20517., 21696.,
      11334., 12120., 12918., 13728., 7172.,  7760.,  8356.,  8960.,
      9598.,  10504., 11422., 12352., 5476.,  6096.,  6724.,  7360.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5361.,  5748.,  6153.,  6576.,  6585.,  7044.,  7521.,  8016.,
      11481., 12228., 12993., 13776., 12705., 13524., 14361., 15216.,
      17601., 18708., 19833., 20976., 18825., 20004., 21201., 22416.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7074.,  7212.,  7584.,  7728.,  8118.,  8268.,  8676.,  8832.,  11685.,
      11946., 12522., 12792., 13395., 13674., 14304., 14592., 8058.,  8268.,
      8664.,  8880.,  9294.,  9516.,  9948.,  10176., 15954., 16332., 16944.,
      17328., 17958., 18348., 18996., 19392., 23565., 24186., 25122., 25752.,
      26715., 27354., 28344., 28992., 15018., 15468., 16104., 16560., 17214.,
      17676., 18348., 18816., 24834., 25452., 26304., 26928., 27798., 28428.,
      29316., 29952., 35445., 36426., 37722., 38712., 40035., 41034., 42384.,
      43392., 21978., 22668., 23544., 24240., 25134., 25836., 26748., 27456.,
      13812., 14344., 14984., 15520., 16172., 16712., 17376., 17920., 18362.,
      19196., 20168., 21008., 21998., 22844., 23852., 24704., 10372., 10952.,
      11608., 12192., 12860., 13448., 14128., 14720.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10497., 10722., 11262., 11496., 12063., 12306., 12900., 13152.,
      12873., 13170., 13782., 14088., 14727., 15042., 15708., 16032.,
      22377., 22962., 23862., 24456., 25383., 25986., 26940., 27552.,
      24753., 25410., 26382., 27048., 28047., 28722., 29748., 30432.,
      34257., 35202., 36462., 37416., 38703., 39666., 40980., 41952.,
      36633., 37650., 38982., 40008., 41367., 42402., 43788., 44832.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14010., 14148., 14286., 14424., 15024., 15168., 15312., 15456., 16086.,
      16236., 16386., 16536., 17196., 17352., 17508., 17664., 23109., 23370.,
      23631., 23892., 24774., 25044., 25314., 25584., 26511., 26790., 27069.,
      27348., 28320., 28608., 28896., 29184., 15906., 16116., 16326., 16536.,
      17112., 17328., 17544., 17760., 18366., 18588., 18810., 19032., 19668.,
      19896., 20124., 20352., 31530., 31908., 32286., 32664., 33504., 33888.,
      34272., 34656., 35526., 35916., 36306., 36696., 37596., 37992., 38388.,
      38784., 46509., 47130., 47751., 48372., 49614., 50244., 50874., 51504.,
      52791., 53430., 54069., 54708., 56040., 56688., 57336., 57984., 29586.,
      30036., 30486., 30936., 31752., 32208., 32664., 33120., 33966., 34428.,
      34890., 35352., 36228., 36696., 37164., 37632., 49050., 49668., 50286.,
      50904., 51984., 52608., 53232., 53856., 54966., 55596., 56226., 56856.,
      57996., 58632., 59268., 59904., 69909., 70890., 71871., 72852., 74454.,
      75444., 76434., 77424., 79071., 80070., 81069., 82068., 83760., 84768.,
      85776., 86784., 43266., 43956., 44646., 45336., 46392., 47088., 47784.,
      48480., 49566., 50268., 50970., 51672., 52788., 53496., 54204., 54912.,
      27092., 27624., 28156., 28688., 29432., 29968., 30504., 31040., 31804.,
      32344., 32884., 33424., 34208., 34752., 35296., 35840., 35890., 36724.,
      37558., 38392., 39496., 40336., 41176., 42016., 43150., 43996., 44842.,
      45688., 46852., 47704., 48556., 49408., 20164., 20744., 21324., 21904.,
      22632., 23216., 23800., 24384., 25132., 25720., 26308., 26896., 27664.,
      28256., 28848., 29440.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20769., 20994., 21219., 21444., 22290., 22524., 22758., 22992., 23883.,
      24126., 24369., 24612., 25548., 25800., 26052., 26304., 25449., 25746.,
      26043., 26340., 27258., 27564., 27870., 28176., 29139., 29454., 29769.,
      30084., 31092., 31416., 31740., 32064., 44169., 44754., 45339., 45924.,
      47130., 47724., 48318., 48912., 50163., 50766., 51369., 51972., 53268.,
      53880., 54492., 55104., 48849., 49506., 50163., 50820., 52098., 52764.,
      53430., 54096., 55419., 56094., 56769., 57444., 58812., 59496., 60180.,
      60864., 67569., 68514., 69459., 70404., 71970., 72924., 73878., 74832.,
      76443., 77406., 78369., 79332., 80988., 81960., 82932., 83904., 72249.,
      73266., 74283., 75300., 76938., 77964., 78990., 80016., 81699., 82734.,
      83769., 84804., 86532., 87576., 88620., 89664.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474.,  564., 384.,  1014.,
                                         1104., 708., 1554., 1644.,
                                         1032., 892., 934.,  553.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474.,  564.,  1014.,
                                         1104., 1554., 1644.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038., 1128., 699.,  768.,  1848., 2028.,
      2010., 2208., 1275., 1416., 2820., 3108., 2982., 3288.,
      1851., 2064., 1538., 1784., 1610., 1868., 928.,  1106.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {876.,  948.,  1038., 1128.,
                                         1848., 2028., 2010., 2208.,
                                         2820., 3108., 2982., 3288.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1986., 2076., 2166., 2256., 1329., 1398.,
      1467., 1536., 3516., 3696., 3876., 4056., 3822., 4020., 4218., 4416.,
      2409., 2550., 2691., 2832., 5352., 5640., 5928., 6216., 5658., 5964.,
      6270., 6576., 3489., 3702., 3915., 4128., 2830., 3076., 3322., 3568.,
      2962., 3220., 3478., 3736., 1678., 1856., 2034., 2212.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1986., 2076., 2166., 2256.,
      3516., 3696., 3876., 4056., 3822., 4020., 4218., 4416.,
      5352., 5640., 5928., 6216., 5658., 5964., 6270., 6576.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1671., 1896., 1995., 2256., 1350., 1536., 3615., 4056.,
      3939., 4416., 2502., 2832., 5559., 6216., 5883., 6576.,
      3654., 4128., 3040., 3568., 3184., 3736., 1836., 2212.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1671., 1896., 1995., 2256.,
                                         3615., 4056., 3939., 4416.,
                                         5559., 6216., 5883., 6576.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207.,  3342.,  3648.,  3792.,  3819.,  3990.,  4332.,  4512.,
      2568.,  2700.,  2934.,  3072.,  6879.,  7230.,  7752.,  8112.,
      7491.,  7878.,  8436.,  8832.,  4728.,  5004.,  5382.,  5664.,
      10551., 11118., 11856., 12432., 11163., 11766., 12540., 13152.,
      6888.,  7308.,  7830.,  8256.,  5594.,  6080.,  6644.,  7136.,
      5858.,  6368.,  6956.,  7472.,  3320.,  3672.,  4068.,  4424.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207.,  3342.,  3648.,  3792.,  3819.,  3990.,  4332.,  4512.,
      6879.,  7230.,  7752.,  8112.,  7491.,  7878.,  8436.,  8832.,
      10551., 11118., 11856., 12432., 11163., 11766., 12540., 13152.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6279.,  6414.,  6549.,  6684.,  7152.,  7296.,  7440.,  7584.,  7467.,
      7638.,  7809.,  7980.,  8484.,  8664.,  8844.,  9024.,  5004.,  5136.,
      5268.,  5400.,  5730.,  5868.,  6006.,  6144.,  13407., 13758., 14109.,
      14460., 15144., 15504., 15864., 16224., 14595., 14982., 15369., 15756.,
      16476., 16872., 17268., 17664., 9180.,  9456.,  9732.,  10008., 10482.,
      10764., 11046., 11328., 20535., 21102., 21669., 22236., 23136., 23712.,
      24288., 24864., 21723., 22326., 22929., 23532., 24468., 25080., 25692.,
      26304., 13356., 13776., 14196., 14616., 15234., 15660., 16086., 16512.,
      10702., 11188., 11674., 12160., 12796., 13288., 13780., 14272., 11206.,
      11716., 12226., 12736., 13396., 13912., 14428., 14944., 6288.,  6640.,
      6992.,  7344.,  7780.,  8136.,  8492.,  8848.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6279.,  6414.,  6549.,  6684.,  7152.,  7296.,  7440.,  7584.,
      7467.,  7638.,  7809.,  7980.,  8484.,  8664.,  8844.,  9024.,
      13407., 13758., 14109., 14460., 15144., 15504., 15864., 16224.,
      14595., 14982., 15369., 15756., 16476., 16872., 17268., 17664.,
      20535., 21102., 21669., 22236., 23136., 23712., 24288., 24864.,
      21723., 22326., 22929., 23532., 24468., 25080., 25692., 26304.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261.,  6684.,  7125.,  7584.,  7485.,  7980.,  8493.,  9024.,
      5046.,  5400.,  5766.,  6144.,  13605., 14460., 15333., 16224.,
      14829., 15756., 16701., 17664., 9366.,  10008., 10662., 11328.,
      20949., 22236., 23541., 24864., 22173., 23532., 24909., 26304.,
      13686., 14616., 15558., 16512., 11122., 12160., 13210., 14272.,
      11650., 12736., 13834., 14944., 6604.,  7344.,  8092.,  8848.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261.,  6684.,  7125.,  7584.,  7485.,  7980.,  8493.,  9024.,
      13605., 14460., 15333., 16224., 14829., 15756., 16701., 17664.,
      20949., 22236., 23541., 24864., 22173., 23532., 24909., 26304.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261., 12522., 13098., 13368., 13971., 14250., 14880., 15168., 14637.,
      14970., 15618., 15960., 16635., 16986., 17688., 18048., 9834.,  10092.,
      10536., 10800., 11262., 11532., 12012., 12288., 26517., 27210., 28218.,
      28920., 29955., 30666., 31728., 32448., 28893., 29658., 30738., 31512.,
      32619., 33402., 34536., 35328., 18186., 18732., 19464., 20016., 20766.,
      21324., 22092., 22656., 40773., 41898., 43338., 44472., 45939., 47082.,
      48576., 49728., 43149., 44346., 45858., 47064., 48603., 49818., 51384.,
      52608., 26538., 27372., 28392., 29232., 30270., 31116., 32172., 33024.,
      21278., 22244., 23348., 24320., 25442., 26420., 27560., 28544., 22286.,
      23300., 24452., 25472., 26642., 27668., 28856., 29888., 12508., 13208.,
      13984., 14688., 15476., 16184., 16984., 17696.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261., 12522., 13098., 13368., 13971., 14250., 14880., 15168.,
      14637., 14970., 15618., 15960., 16635., 16986., 17688., 18048.,
      26517., 27210., 28218., 28920., 29955., 30666., 31728., 32448.,
      28893., 29658., 30738., 31512., 32619., 33402., 34536., 35328.,
      40773., 41898., 43338., 44472., 45939., 47082., 48576., 49728.,
      43149., 44346., 45858., 47064., 48603., 49818., 51384., 52608.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24261., 24522., 24783., 25044., 25926.,  26196.,  26466.,  26736.,
      27663., 27942., 28221., 28500., 29472.,  29760.,  30048.,  30336.,
      28941., 29274., 29607., 29940., 30894.,  31236.,  31578.,  31920.,
      32919., 33270., 33621., 33972., 35016.,  35376.,  35736.,  36096.,
      19410., 19668., 19926., 20184., 20808.,  21072.,  21336.,  21600.,
      22254., 22524., 22794., 23064., 23748.,  24024.,  24300.,  24576.,
      52341., 53034., 53727., 54420., 55734.,  56436.,  57138.,  57840.,
      59199., 59910., 60621., 61332., 62736.,  63456.,  64176.,  64896.,
      57021., 57786., 58551., 59316., 60702.,  61476.,  62250.,  63024.,
      64455., 65238., 66021., 66804., 68280.,  69072.,  69864.,  70656.,
      35826., 36372., 36918., 37464., 38376.,  38928.,  39480.,  40032.,
      40974., 41532., 42090., 42648., 43620.,  44184.,  44748.,  45312.,
      80421., 81546., 82671., 83796., 85542.,  86676.,  87810.,  88944.,
      90735., 91878., 93021., 94164., 96000.,  97152.,  98304.,  99456.,
      85101., 86298., 87495., 88692., 90510.,  91716.,  92922.,  94128.,
      95991., 97206., 98421., 99636., 101544., 102768., 103992., 105216.,
      52242., 53076., 53910., 54744., 55944.,  56784.,  57624.,  58464.,
      59694., 60540., 61386., 62232., 63492.,  64344.,  65196.,  66048.,
      41590., 42556., 43522., 44488., 45724.,  46696.,  47668.,  48640.,
      49906., 50884., 51862., 52840., 54136.,  55120.,  56104.,  57088.,
      43558., 44572., 45586., 46600., 47884.,  48904.,  49924.,  50944.,
      52258., 53284., 54310., 55336., 56680.,  57712.,  58744.,  59776.,
      24316., 25016., 25716., 26416., 27264.,  27968.,  28672.,  29376.,
      30244., 30952., 31660., 32368., 33256.,  33968.,  34680.,  35392.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24261., 24522., 24783.,  25044.,  25926.,  26196., 26466., 26736., 27663.,
      27942., 28221., 28500.,  29472.,  29760.,  30048., 30336., 28941., 29274.,
      29607., 29940., 30894.,  31236.,  31578.,  31920., 32919., 33270., 33621.,
      33972., 35016., 35376.,  35736.,  36096.,  52341., 53034., 53727., 54420.,
      55734., 56436., 57138.,  57840.,  59199.,  59910., 60621., 61332., 62736.,
      63456., 64176., 64896.,  57021.,  57786.,  58551., 59316., 60702., 61476.,
      62250., 63024., 64455.,  65238.,  66021.,  66804., 68280., 69072., 69864.,
      70656., 80421., 81546.,  82671.,  83796.,  85542., 86676., 87810., 88944.,
      90735., 91878., 93021.,  94164.,  96000.,  97152., 98304., 99456., 85101.,
      86298., 87495., 88692.,  90510.,  91716.,  92922., 94128., 95991., 97206.,
      98421., 99636., 101544., 102768., 103992., 105216.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  516.,  1320., 1410., 1500., 948.,
      2040., 2130., 2220., 1380., 1174., 1216., 1258., 739.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {600.,  690.,  780.,  1320., 1410.,
                                         1500., 2040., 2130., 2220.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110., 1200., 1272., 1380., 1434., 1560., 939.,  1032.,
      2406., 2640., 2568., 2820., 2730., 3000., 1707., 1896.,
      3702., 4080., 3864., 4260., 4026., 4440., 2475., 2760.,
      2024., 2348., 2096., 2432., 2168., 2516., 1240., 1478.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110., 1200., 1272., 1380., 1434., 1560., 2406., 2640., 2568.,
      2820., 2730., 3000., 3702., 4080., 3864., 4260., 4026., 4440.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130., 2220., 2310., 2400., 2436., 2544., 2652., 2760., 2742., 2868.,
      2994., 3120., 1785., 1878., 1971., 2064., 4578., 4812., 5046., 5280.,
      4884., 5136., 5388., 5640., 5190., 5460., 5730., 6000., 3225., 3414.,
      3603., 3792., 7026., 7404., 7782., 8160., 7332., 7728., 8124., 8520.,
      7638., 8052., 8466., 8880., 4665., 4950., 5235., 5520., 3724., 4048.,
      4372., 4696., 3856., 4192., 4528., 4864., 3988., 4336., 4684., 5032.,
      2242., 2480., 2718., 2956.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130., 2220., 2310., 2400., 2436., 2544., 2652., 2760., 2742.,
      2868., 2994., 3120., 4578., 4812., 5046., 5280., 4884., 5136.,
      5388., 5640., 5190., 5460., 5730., 6000., 7026., 7404., 7782.,
      8160., 7332., 7728., 8124., 8520., 7638., 8052., 8466., 8880.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2139., 2400., 2463., 2760., 2787., 3120., 1830., 2064.,
      4731., 5280., 5055., 5640., 5379., 6000., 3366., 3792.,
      7323., 8160., 7647., 8520., 7971., 8880., 4902., 5520.,
      4012., 4696., 4156., 4864., 4300., 5032., 2460., 2956.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2139., 2400., 2463., 2760., 2787., 3120., 4731., 5280., 5055.,
      5640., 5379., 6000., 7323., 8160., 7647., 8520., 7971., 8880.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107.,  4278.,  4620.,  4800.,  4719.,  4926.,  5304.,  5520.,
      5331.,  5574.,  5988.,  6240.,  3480.,  3660.,  3942.,  4128.,
      9003.,  9462.,  10092., 10560., 9615.,  10110., 10776., 11280.,
      10227., 10758., 11460., 12000., 6360.,  6732.,  7206.,  7584.,
      13899., 14646., 15564., 16320., 14511., 15294., 16248., 17040.,
      15123., 15942., 16932., 17760., 9240.,  9804.,  10470., 11040.,
      7382.,  8024.,  8744.,  9392.,  7646.,  8312.,  9056.,  9728.,
      7910.,  8600.,  9368.,  10064., 4448.,  4920.,  5436.,  5912.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107.,  4278.,  4620.,  4800.,  4719.,  4926.,  5304.,  5520.,  5331.,
      5574.,  5988.,  6240.,  9003.,  9462.,  10092., 10560., 9615.,  10110.,
      10776., 11280., 10227., 10758., 11460., 12000., 13899., 14646., 15564.,
      16320., 14511., 15294., 16248., 17040., 15123., 15942., 16932., 17760.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8043.,  8214.,  8385.,  8556.,  9060.,  9240.,  9420.,  9600.,  9231.,
      9438.,  9645.,  9852.,  10392., 10608., 10824., 11040., 10419., 10662.,
      10905., 11148., 11724., 11976., 12228., 12480., 6780.,  6960.,  7140.,
      7320.,  7698.,  7884.,  8070.,  8256.,  17547., 18006., 18465., 18924.,
      19716., 20184., 20652., 21120., 18735., 19230., 19725., 20220., 21048.,
      21552., 22056., 22560., 19923., 20454., 20985., 21516., 22380., 22920.,
      23460., 24000., 12348., 12720., 13092., 13464., 14034., 14412., 14790.,
      15168., 27051., 27798., 28545., 29292., 30372., 31128., 31884., 32640.,
      28239., 29022., 29805., 30588., 31704., 32496., 33288., 34080., 29427.,
      30246., 31065., 31884., 33036., 33864., 34692., 35520., 17916., 18480.,
      19044., 19608., 20370., 20940., 21510., 22080., 14122., 14764., 15406.,
      16048., 16840., 17488., 18136., 18784., 14626., 15292., 15958., 16624.,
      17440., 18112., 18784., 19456., 15130., 15820., 16510., 17200., 18040.,
      18736., 19432., 20128., 8424.,  8896.,  9368.,  9840.,  10396., 10872.,
      11348., 11824.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8043.,  8214.,  8385.,  8556.,  9060.,  9240.,  9420.,  9600.,  9231.,
      9438.,  9645.,  9852.,  10392., 10608., 10824., 11040., 10419., 10662.,
      10905., 11148., 11724., 11976., 12228., 12480., 17547., 18006., 18465.,
      18924., 19716., 20184., 20652., 21120., 18735., 19230., 19725., 20220.,
      21048., 21552., 22056., 22560., 19923., 20454., 20985., 21516., 22380.,
      22920., 23460., 24000., 27051., 27798., 28545., 29292., 30372., 31128.,
      31884., 32640., 28239., 29022., 29805., 30588., 31704., 32496., 33288.,
      34080., 29427., 30246., 31065., 31884., 33036., 33864., 34692., 35520.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,  8556.,  9069.,  9600.,  9285.,  9852.,  10437., 11040.,
      10509., 11148., 11805., 12480., 6870.,  7320.,  7782.,  8256.,
      17853., 18924., 20013., 21120., 19077., 20220., 21381., 22560.,
      20301., 21516., 22749., 24000., 12630., 13464., 14310., 15168.,
      27645., 29292., 30957., 32640., 28869., 30588., 32325., 34080.,
      30093., 31884., 33693., 35520., 18390., 19608., 20838., 22080.,
      14698., 16048., 17410., 18784., 15226., 16624., 18034., 19456.,
      15754., 17200., 18658., 20128., 8860.,  9840.,  10828., 11824.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,  8556.,  9069.,  9600.,  9285.,  9852.,  10437., 11040., 10509.,
      11148., 11805., 12480., 17853., 18924., 20013., 21120., 19077., 20220.,
      21381., 22560., 20301., 21516., 22749., 24000., 27645., 29292., 30957.,
      32640., 28869., 30588., 32325., 34080., 30093., 31884., 33693., 35520.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789., 16122., 16770., 17112., 17787., 18138., 18840., 19200., 18165.,
      18570., 19290., 19704., 20451., 20874., 21648., 22080., 20541., 21018.,
      21810., 22296., 23115., 23610., 24456., 24960., 13386., 13740., 14280.,
      14640., 15198., 15564., 16140., 16512., 34797., 35706., 36930., 37848.,
      39099., 40026., 41304., 42240., 37173., 38154., 39450., 40440., 41763.,
      42762., 44112., 45120., 39549., 40602., 41970., 43032., 44427., 45498.,
      46920., 48000., 24522., 25260., 26184., 26928., 27870., 28620., 29580.,
      30336., 53805., 55290., 57090., 58584., 60411., 61914., 63768., 65280.,
      56181., 57738., 59610., 61176., 63075., 64650., 66576., 68160., 58557.,
      60186., 62130., 63768., 65739., 67386., 69384., 71040., 35658., 36780.,
      38088., 39216., 40542., 41676., 43020., 44160., 28118., 29396., 30812.,
      32096., 33530., 34820., 36272., 37568., 29126., 30452., 31916., 33248.,
      34730., 36068., 37568., 38912., 30134., 31508., 33020., 34400., 35930.,
      37316., 38864., 40256., 16780., 17720., 18736., 19680., 20708., 21656.,
      22696., 23648.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789., 16122., 16770., 17112., 17787., 18138., 18840., 19200., 18165.,
      18570., 19290., 19704., 20451., 20874., 21648., 22080., 20541., 21018.,
      21810., 22296., 23115., 23610., 24456., 24960., 34797., 35706., 36930.,
      37848., 39099., 40026., 41304., 42240., 37173., 38154., 39450., 40440.,
      41763., 42762., 44112., 45120., 39549., 40602., 41970., 43032., 44427.,
      45498., 46920., 48000., 53805., 55290., 57090., 58584., 60411., 61914.,
      63768., 65280., 56181., 57738., 59610., 61176., 63075., 64650., 66576.,
      68160., 58557., 60186., 62130., 63768., 65739., 67386., 69384., 71040.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31245.,  31578.,  31911.,  32244.,  33198.,  33540.,  33882.,  34224.,
      35223.,  35574.,  35925.,  36276.,  37320.,  37680.,  38040.,  38400.,
      35925.,  36330.,  36735.,  37140.,  38166.,  38580.,  38994.,  39408.,
      40479.,  40902.,  41325.,  41748.,  42864.,  43296.,  43728.,  44160.,
      40605.,  41082.,  41559.,  42036.,  43134.,  43620.,  44106.,  44592.,
      45735.,  46230.,  46725.,  47220.,  48408.,  48912.,  49416.,  49920.,
      26418.,  26772.,  27126.,  27480.,  28200.,  28560.,  28920.,  29280.,
      30030.,  30396.,  30762.,  31128.,  31908.,  32280.,  32652.,  33024.,
      68685.,  69594.,  70503.,  71412.,  72942.,  73860.,  74778.,  75696.,
      77271.,  78198.,  79125.,  80052.,  81672.,  82608.,  83544.,  84480.,
      73365.,  74346.,  75327.,  76308.,  77910.,  78900.,  79890.,  80880.,
      82527.,  83526.,  84525.,  85524.,  87216.,  88224.,  89232.,  90240.,
      78045.,  79098.,  80151.,  81204.,  82878.,  83940.,  85002.,  86064.,
      87783.,  88854.,  89925.,  90996.,  92760.,  93840.,  94920.,  96000.,
      48306.,  49044.,  49782.,  50520.,  51624.,  52368.,  53112.,  53856.,
      54990.,  55740.,  56490.,  57240.,  58404.,  59160.,  59916.,  60672.,
      106125., 107610., 109095., 110580., 112686., 114180., 115674., 117168.,
      119319., 120822., 122325., 123828., 126024., 127536., 129048., 130560.,
      110805., 112362., 113919., 115476., 117654., 119220., 120786., 122352.,
      124575., 126150., 127725., 129300., 131568., 133152., 134736., 136320.,
      115485., 117114., 118743., 120372., 122622., 124260., 125898., 127536.,
      129831., 131478., 133125., 134772., 137112., 138768., 140424., 142080.,
      70194.,  71316.,  72438.,  73560.,  75048.,  76176.,  77304.,  78432.,
      79950.,  81084.,  82218.,  83352.,  84900.,  86040.,  87180.,  88320.,
      54958.,  56236.,  57514.,  58792.,  60340.,  61624.,  62908.,  64192.,
      65770.,  67060.,  68350.,  69640.,  71248.,  72544.,  73840.,  75136.,
      56926.,  58252.,  59578.,  60904.,  62500.,  63832.,  65164.,  66496.,
      68122.,  69460.,  70798.,  72136.,  73792.,  75136.,  76480.,  77824.,
      58894.,  60268.,  61642.,  63016.,  64660.,  66040.,  67420.,  68800.,
      70474.,  71860.,  73246.,  74632.,  76336.,  77728.,  79120.,  80512.,
      32620.,  33560.,  34500.,  35440.,  36528.,  37472.,  38416.,  39360.,
      40468.,  41416.,  42364.,  43312.,  44440.,  45392.,  46344.,  47296.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31245.,  31578.,  31911.,  32244.,  33198.,  33540.,  33882.,  34224.,
      35223.,  35574.,  35925.,  36276.,  37320.,  37680.,  38040.,  38400.,
      35925.,  36330.,  36735.,  37140.,  38166.,  38580.,  38994.,  39408.,
      40479.,  40902.,  41325.,  41748.,  42864.,  43296.,  43728.,  44160.,
      40605.,  41082.,  41559.,  42036.,  43134.,  43620.,  44106.,  44592.,
      45735.,  46230.,  46725.,  47220.,  48408.,  48912.,  49416.,  49920.,
      68685.,  69594.,  70503.,  71412.,  72942.,  73860.,  74778.,  75696.,
      77271.,  78198.,  79125.,  80052.,  81672.,  82608.,  83544.,  84480.,
      73365.,  74346.,  75327.,  76308.,  77910.,  78900.,  79890.,  80880.,
      82527.,  83526.,  84525.,  85524.,  87216.,  88224.,  89232.,  90240.,
      78045.,  79098.,  80151.,  81204.,  82878.,  83940.,  85002.,  86064.,
      87783.,  88854.,  89925.,  90996.,  92760.,  93840.,  94920.,  96000.,
      106125., 107610., 109095., 110580., 112686., 114180., 115674., 117168.,
      119319., 120822., 122325., 123828., 126024., 127536., 129048., 130560.,
      110805., 112362., 113919., 115476., 117654., 119220., 120786., 122352.,
      124575., 126150., 127725., 129300., 131568., 133152., 134736., 136320.,
      115485., 117114., 118743., 120372., 122622., 124260., 125898., 127536.,
      129831., 131478., 133125., 134772., 137112., 138768., 140424., 142080.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      128.,  241.,  184.,  441.,  681.,  453.,  320.,  457.,  280.,
      828.,  1216., 784.,  1266., 1806., 1128., 720.,  982.,  580.,
      1528., 2191., 1384., 2091., 2931., 1803., 1120., 1507., 880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411.,  501.,  861.,  951.,
                                         1536., 1626., 1986., 2076.,
                                         2661., 2751., 3111., 3201.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240.,  256.,  449.,  482.,  340.,  368.,  813.,  882.,  1245.,
      1362., 819.,  906.,  564.,  640.,  791.,  914.,  472.,  560.,
      1540., 1656., 2249., 2432., 1440., 1568., 2313., 2532., 3270.,
      3612., 2019., 2256., 1264., 1440., 1691., 1964., 972.,  1160.,
      2840., 3056., 4049., 4382., 2540., 2768., 3813., 4182., 5295.,
      5862., 3219., 3606., 1964., 2240., 2591., 3014., 1472., 1760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  921.,  1002., 1569., 1722., 1731., 1902.,
      2784., 3072., 2946., 3252., 3594., 3972., 3756., 4152.,
      4809., 5322., 4971., 5502., 5619., 6222., 5781., 6402.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      464.,   480.,   496.,  512.,  865.,  898.,  931.,  964.,  652.,   680.,
      708.,   736.,   1557., 1626., 1695., 1764., 2373., 2490., 2607.,  2724.,
      1551.,  1638.,  1725., 1812., 1052., 1128., 1204., 1280., 1459.,  1582.,
      1705.,  1828.,  856.,  944.,  1032., 1120., 2964., 3080., 3196.,  3312.,
      4315.,  4498.,  4681., 4864., 2752., 2880., 3008., 3136., 4407.,  4626.,
      4845.,  5064.,  6198., 6540., 6882., 7224., 3801., 4038., 4275.,  4512.,
      2352.,  2528.,  2704., 2880., 3109., 3382., 3655., 3928., 1756.,  1944.,
      2132.,  2320.,  5464., 5680., 5896., 6112., 7765., 8098., 8431.,  8764.,
      4852.,  5080.,  5308., 5536., 7257., 7626., 7995., 8364., 10023., 10590.,
      11157., 11724., 6051., 6438., 6825., 7212., 3652., 3928., 4204.,  4480.,
      4759.,  5182.,  5605., 6028., 2656., 2944., 3232., 3520.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455.,  1518.,  1581.,  1644.,  1761.,  1842.,  1923.,  2004.,
      2985.,  3138.,  3291.,  3444.,  3291.,  3462.,  3633.,  3804.,
      5280.,  5568.,  5856.,  6144.,  5586.,  5892.,  6198.,  6504.,
      6810.,  7188.,  7566.,  7944.,  7116.,  7512.,  7908.,  8304.,
      9105.,  9618.,  10131., 10644., 9411.,  9942.,  10473., 11004.,
      10635., 11238., 11841., 12444., 10941., 11562., 12183., 12804.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      428.,   512.,  826.,  964.,  636.,  736.,  1566., 1764., 2409.,
      2724.,  1590., 1812., 1100., 1280., 1546., 1828., 924.,  1120.,
      3028.,  3312., 4426., 4864., 2836., 3136., 4566., 5064., 6459.,
      7224.,  3990., 4512., 2500., 2880., 3346., 3928., 1924., 2320.,
      5628.,  6112., 8026., 8764., 5036., 5536., 7566., 8364., 10509.,
      11724., 6390., 7212., 3900., 4480., 5146., 6028., 2924., 3520.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1437., 1644.,  1761., 2004.,  3057.,  3444.,  3381.,  3804.,
      5487., 6144.,  5811., 6504.,  7107.,  7944.,  7431.,  8304.,
      9537., 10644., 9861., 11004., 11157., 12444., 11481., 12804.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      828.,   856.,   992.,   1024.,  1592.,  1652.,  1862.,  1928.,  1220.,
      1272.,  1416.,  1472.,  3000.,  3132.,  3390.,  3528.,  4593.,  4818.,
      5214.,  5448.,  3012.,  3180.,  3450.,  3624.,  2052.,  2200.,  2408.,
      2560.,  2852.,  3092.,  3410.,  3656.,  1676.,  1848.,  2064.,  2240.,
      5828.,  6056.,  6392.,  6624.,  8492.,  8852.,  9362.,  9728.,  5420.,
      5672.,  6016.,  6272.,  8700.,  9132.,  9690.,  10128., 12243., 12918.,
      13764., 14448., 7512.,  7980.,  8550.,  9024.,  4652.,  5000.,  5408.,
      5760.,  6152.,  6692.,  7310.,  7856.,  3476.,  3848.,  4264.,  4640.,
      10828., 11256., 11792., 12224., 15392., 16052., 16862., 17528., 9620.,
      10072., 10616., 11072., 14400., 15132., 15990., 16728., 19893., 21018.,
      22314., 23448., 12012., 12780., 13650., 14424., 7252.,  7800.,  8408.,
      8960.,  9452.,  10292., 11210., 12056., 5276.,  5848.,  6464.,  7040.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2757.,  2874.,  3162.,  3288.,  3369.,  3522.,  3846.,  4008.,
      5817.,  6114.,  6582.,  6888.,  6429.,  6762.,  7266.,  7608.,
      10407., 10974., 11712., 12288., 11019., 11622., 12396., 13008.,
      13467., 14214., 15132., 15888., 14079., 14862., 15816., 16608.,
      18057., 19074., 20262., 21288., 18669., 19722., 20946., 22008.,
      21117., 22314., 23682., 24888., 21729., 22962., 24366., 25608.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1628.,  1656.,  1684.,  1712.,  1952.,  1984.,  2016.,  2048.,  3124.,
      3184.,  3244.,  3304.,  3658.,  3724.,  3790.,  3856.,  2388.,  2440.,
      2492.,  2544.,  2776.,  2832.,  2888.,  2944.,  5868.,  6000.,  6132.,
      6264.,  6642.,  6780.,  6918.,  7056.,  8961.,  9186.,  9411.,  9636.,
      10194., 10428., 10662., 10896., 5856.,  6024.,  6192.,  6360.,  6726.,
      6900.,  7074.,  7248.,  3956.,  4104.,  4252.,  4400.,  4664.,  4816.,
      4968.,  5120.,  5464.,  5704.,  5944.,  6184.,  6574.,  6820.,  7066.,
      7312.,  3180.,  3352.,  3524.,  3696.,  3952.,  4128.,  4304.,  4480.,
      11428., 11656., 11884., 12112., 12552., 12784., 13016., 13248., 16624.,
      16984., 17344., 17704., 18358., 18724., 19090., 19456., 10588., 10840.,
      11092., 11344., 11776., 12032., 12288., 12544., 16968., 17400., 17832.,
      18264., 18942., 19380., 19818., 20256., 23811., 24486., 25161., 25836.,
      26844., 27528., 28212., 28896., 14556., 15024., 15492., 15960., 16626.,
      17100., 17574., 18048., 8956.,  9304.,  9652.,  10000., 10464., 10816.,
      11168., 11520., 11764., 12304., 12844., 13384., 14074., 14620., 15166.,
      15712., 6580.,  6952.,  7324.,  7696.,  8152.,  8528.,  8904.,  9280.,
      21228., 21656., 22084., 22512., 23152., 23584., 24016., 24448., 30124.,
      30784., 31444., 32104., 33058., 33724., 34390., 35056., 18788., 19240.,
      19692., 20144., 20776., 21232., 21688., 22144., 28068., 28800., 29532.,
      30264., 31242., 31980., 32718., 33456., 38661., 39786., 40911., 42036.,
      43494., 44628., 45762., 46896., 23256., 24024., 24792., 25560., 26526.,
      27300., 28074., 28848., 13956., 14504., 15052., 15600., 16264., 16816.,
      17368., 17920., 18064., 18904., 19744., 20584., 21574., 22420., 23266.,
      24112., 9980.,  10552., 11124., 11696., 12352., 12928., 13504., 14080.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5397.,  5514.,  5631.,  5748.,  6198.,  6324.,  6450.,  6576.,  6585.,
      6738.,  6891.,  7044.,  7530.,  7692.,  7854.,  8016.,  11337., 11634.,
      11931., 12228., 12858., 13164., 13470., 13776., 12525., 12858., 13191.,
      13524., 14190., 14532., 14874., 15216., 20247., 20814., 21381., 21948.,
      22848., 23424., 24000., 24576., 21435., 22038., 22641., 23244., 24180.,
      24792., 25404., 26016., 26187., 26934., 27681., 28428., 29508., 30264.,
      31020., 31776., 27375., 28158., 28941., 29724., 30840., 31632., 32424.,
      33216., 35097., 36114., 37131., 38148., 39498., 40524., 41550., 42576.,
      36285., 37338., 38391., 39444., 40830., 41892., 42954., 44016., 41037.,
      42234., 43431., 44628., 46158., 47364., 48570., 49776., 42225., 43458.,
      44691., 45924., 47490., 48732., 49974., 51216.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1556.,  1712.,  1876.,  2048.,  3046.,  3304.,  3574.,  3856.,  2356.,
      2544.,  2740.,  2944.,  5886.,  6264.,  6654.,  7056.,  9033.,  9636.,
      10257., 10896., 5934.,  6360.,  6798.,  7248.,  4052.,  4400.,  4756.,
      5120.,  5638.,  6184.,  6742.,  7312.,  3316.,  3696.,  4084.,  4480.,
      11556., 12112., 12676., 13248., 16846., 17704., 18574., 19456., 10756.,
      11344., 11940., 12544., 17286., 18264., 19254., 20256., 24333., 25836.,
      27357., 28896., 14934., 15960., 16998., 18048., 9252.,  10000., 10756.,
      11520., 12238., 13384., 14542., 15712., 6916.,  7696.,  8484.,  9280.,
      21556., 22512., 23476., 24448., 30646., 32104., 33574., 35056., 19156.,
      20144., 21140., 22144., 28686., 30264., 31854., 33456., 39633., 42036.,
      44457., 46896., 23934., 25560., 27198., 28848., 14452., 15600., 16756.,
      17920., 18838., 20584., 22342., 24112., 10516., 11696., 12884., 14080.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5361.,  5748.,  6153.,  6576.,  6585.,  7044.,  7521.,  8016.,
      11481., 12228., 12993., 13776., 12705., 13524., 14361., 15216.,
      20661., 21948., 23253., 24576., 21885., 23244., 24621., 26016.,
      26781., 28428., 30093., 31776., 28005., 29724., 31461., 33216.,
      35961., 38148., 40353., 42576., 37185., 39444., 41721., 44016.,
      42081., 44628., 47193., 49776., 43305., 45924., 48561., 51216.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3060.,  3112.,  3368.,  3424.,  3692.,  3752.,  4032.,  4096.,  5978.,
      6092.,  6488.,  6608.,  7022.,  7148.,  7580.,  7712.,  4612.,  4712.,
      4984.,  5088.,  5372.,  5480.,  5776.,  5888.,  11514., 11772., 12264.,
      12528., 13038., 13308., 13836., 14112., 17625., 18066., 18822., 19272.,
      20055., 20514., 21324., 21792., 11538., 11868., 12384., 12720., 13254.,
      13596., 14148., 14496., 7812.,  8104.,  8504.,  8800.,  9212.,  9512.,
      9936.,  10240., 10802., 11276., 11888., 12368., 12998., 13484., 14132.,
      14624., 6292.,  6632.,  7048.,  7392.,  7820.,  8168.,  8608.,  8960.,
      22660., 23112., 23768., 24224., 24892., 25352., 26032., 26496., 32978.,
      33692., 34688., 35408., 36422., 37148., 38180., 38912., 21012., 21512.,
      22184., 22688., 23372., 23880., 24576., 25088., 33714., 34572., 35664.,
      36528., 37638., 38508., 39636., 40512., 47325., 48666., 50322., 51672.,
      53355., 54714., 56424., 57792., 28938., 29868., 30984., 31920., 33054.,
      33996., 35148., 36096., 17812., 18504., 19304., 20000., 20812., 21512.,
      22336., 23040., 23402., 24476., 25688., 26768., 27998., 29084., 30332.,
      31424., 13092., 13832., 14648., 15392., 16220., 16968., 17808., 18560.,
      42260., 43112., 44168., 45024., 46092., 46952., 48032., 48896., 59978.,
      61292., 62888., 64208., 65822., 67148., 68780., 70112., 37412., 38312.,
      39384., 40288., 41372., 42280., 43376., 44288., 55914., 57372., 59064.,
      60528., 62238., 63708., 65436., 66912., 77025., 79266., 81822., 84072.,
      86655., 88914., 91524., 93792., 46338., 47868., 49584., 51120., 52854.,
      54396., 56148., 57696., 27812., 28904., 30104., 31200., 32412., 33512.,
      34736., 35840., 36002., 37676., 39488., 41168., 42998., 44684., 46532.,
      48224., 19892., 21032., 22248., 23392., 24620., 25768., 27008., 28160.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10497., 10722., 11262., 11496., 12063., 12306., 12900., 13152., 12873.,
      13170., 13782., 14088., 14727., 15042., 15708., 16032., 22377., 22962.,
      23862., 24456., 25383., 25986., 26940., 27552., 24753., 25410., 26382.,
      27048., 28047., 28722., 29748., 30432., 40197., 41322., 42762., 43896.,
      45363., 46506., 48000., 49152., 42573., 43770., 45282., 46488., 48027.,
      49242., 50808., 52032., 52077., 53562., 55362., 56856., 58683., 60186.,
      62040., 63552., 54453., 56010., 57882., 59448., 61347., 62922., 64848.,
      66432., 69897., 71922., 74262., 76296., 78663., 80706., 83100., 85152.,
      72273., 74370., 76782., 78888., 81327., 83442., 85908., 88032., 81777.,
      84162., 86862., 89256., 91983., 94386., 97140., 99552., 84153., 86610.,
      89382., 91848., 94647., 97122., 99948., 102432.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6068.,   6120.,   6172.,   6224.,   6680.,   6736.,   6792.,   6848.,
      7324.,   7384.,   7444.,   7504.,   8000.,   8064.,   8128.,   8192.,
      11842.,  11956.,  12070.,  12184.,  12856.,  12976.,  13096.,  13216.,
      13918.,  14044.,  14170.,  14296.,  15028.,  15160.,  15292.,  15424.,
      9124.,   9224.,   9324.,   9424.,   9864.,   9968.,   10072.,  10176.,
      10636.,  10744.,  10852.,  10960.,  11440.,  11552.,  11664.,  11776.,
      22770.,  23028.,  23286.,  23544.,  24264.,  24528.,  24792.,  25056.,
      25806.,  26076.,  26346.,  26616.,  27396.,  27672.,  27948.,  28224.,
      34809.,  35250.,  35691.,  36132.,  37194.,  37644.,  38094.,  38544.,
      39651.,  40110.,  40569.,  41028.,  42180.,  42648.,  43116.,  43584.,
      22746.,  23076.,  23406.,  23736.,  24432.,  24768.,  25104.,  25440.,
      26166.,  26508.,  26850.,  27192.,  27948.,  28296.,  28644.,  28992.,
      15332.,  15624.,  15916.,  16208.,  16712.,  17008.,  17304.,  17600.,
      18124.,  18424.,  18724.,  19024.,  19568.,  19872.,  20176.,  20480.,
      21130.,  21604.,  22078.,  22552.,  23296.,  23776.,  24256.,  24736.,
      25510.,  25996.,  26482.,  26968.,  27772.,  28264.,  28756.,  29248.,
      12244.,  12584.,  12924.,  13264.,  13752.,  14096.,  14440.,  14784.,
      15292.,  15640.,  15988.,  16336.,  16864.,  17216.,  17568.,  17920.,
      44868.,  45320.,  45772.,  46224.,  47080.,  47536.,  47992.,  48448.,
      49324.,  49784.,  50244.,  50704.,  51600.,  52064.,  52528.,  52992.,
      65242.,  65956.,  66670.,  67384.,  68656.,  69376.,  70096.,  70816.,
      72118.,  72844.,  73570.,  74296.,  75628.,  76360.,  77092.,  77824.,
      41524.,  42024.,  42524.,  43024.,  43864.,  44368.,  44872.,  45376.,
      46236.,  46744.,  47252.,  47760.,  48640.,  49152.,  49664.,  50176.,
      66570.,  67428.,  68286.,  69144.,  70464.,  71328.,  72192.,  73056.,
      74406.,  75276.,  76146.,  77016.,  78396.,  79272.,  80148.,  81024.,
      93309.,  94650.,  95991.,  97332.,  99294.,  100644., 101994., 103344.,
      105351., 106710., 108069., 109428., 111480., 112848., 114216., 115584.,
      56946.,  57876.,  58806.,  59736.,  61032.,  61968.,  62904.,  63840.,
      65166.,  66108.,  67050.,  67992.,  69348.,  70296.,  71244.,  72192.,
      34932.,  35624.,  36316.,  37008.,  37912.,  38608.,  39304.,  40000.,
      40924.,  41624.,  42324.,  43024.,  43968.,  44672.,  45376.,  46080.,
      45730.,  46804.,  47878.,  48952.,  50296.,  51376.,  52456.,  53536.,
      54910.,  55996.,  57082.,  58168.,  59572.,  60664.,  61756.,  62848.,
      25444.,  26184.,  26924.,  27664.,  28552.,  29296.,  30040.,  30784.,
      31692.,  32440.,  33188.,  33936.,  34864.,  35616.,  36368.,  37120.,
      83668.,  84520.,  85372.,  86224.,  87480.,  88336.,  89192.,  90048.,
      91324.,  92184.,  93044.,  93904.,  95200.,  96064.,  96928.,  97792.,
      118642., 119956., 121270., 122584., 124456., 125776., 127096., 128416.,
      130318., 131644., 132970., 134296., 136228., 137560., 138892., 140224.,
      73924.,  74824.,  75724.,  76624.,  77864.,  78768.,  79672.,  80576.,
      81836.,  82744.,  83652.,  84560.,  85840.,  86752.,  87664.,  88576.,
      110370., 111828., 113286., 114744., 116664., 118128., 119592., 121056.,
      123006., 124476., 125946., 127416., 129396., 130872., 132348., 133824.,
      151809., 154050., 156291., 158532., 161394., 163644., 165894., 168144.,
      171051., 173310., 175569., 177828., 180780., 183048., 185316., 187584.,
      91146.,  92676.,  94206.,  95736.,  97632.,  99168.,  100704., 102240.,
      104166., 105708., 107250., 108792., 110748., 112296., 113844., 115392.,
      54532.,  55624.,  56716.,  57808.,  59112.,  60208.,  61304.,  62400.,
      63724.,  64824.,  65924.,  67024.,  68368.,  69472.,  70576.,  71680.,
      70330.,  72004.,  73678.,  75352.,  77296.,  78976.,  80656.,  82336.,
      84310.,  85996.,  87682.,  89368.,  91372.,  93064.,  94756.,  96448.,
      38644.,  39784.,  40924.,  42064.,  43352.,  44496.,  45640.,  46784.,
      48092.,  49240.,  50388.,  51536.,  52864.,  54016.,  55168.,  56320.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20769.,  20994.,  21219.,  21444.,  22290.,  22524.,  22758.,  22992.,
      23883.,  24126.,  24369.,  24612.,  25548.,  25800.,  26052.,  26304.,
      25449.,  25746.,  26043.,  26340.,  27258.,  27564.,  27870.,  28176.,
      29139.,  29454.,  29769.,  30084.,  31092.,  31416.,  31740.,  32064.,
      44169.,  44754.,  45339.,  45924.,  47130.,  47724.,  48318.,  48912.,
      50163.,  50766.,  51369.,  51972.,  53268.,  53880.,  54492.,  55104.,
      48849.,  49506.,  50163.,  50820.,  52098.,  52764.,  53430.,  54096.,
      55419.,  56094.,  56769.,  57444.,  58812.,  59496.,  60180.,  60864.,
      79269.,  80394.,  81519.,  82644.,  84390.,  85524.,  86658.,  87792.,
      89583.,  90726.,  91869.,  93012.,  94848.,  96000.,  97152.,  98304.,
      83949.,  85146.,  86343.,  87540.,  89358.,  90564.,  91770.,  92976.,
      94839.,  96054.,  97269.,  98484.,  100392., 101616., 102840., 104064.,
      102669., 104154., 105639., 107124., 109230., 110724., 112218., 113712.,
      115863., 117366., 118869., 120372., 122568., 124080., 125592., 127104.,
      107349., 108906., 110463., 112020., 114198., 115764., 117330., 118896.,
      121119., 122694., 124269., 125844., 128112., 129696., 131280., 132864.,
      137769., 139794., 141819., 143844., 146490., 148524., 150558., 152592.,
      155283., 157326., 159369., 161412., 164148., 166200., 168252., 170304.,
      142449., 144546., 146643., 148740., 151458., 153564., 155670., 157776.,
      160539., 162654., 164769., 166884., 169692., 171816., 173940., 176064.,
      161169., 163554., 165939., 168324., 171330., 173724., 176118., 178512.,
      181563., 183966., 186369., 188772., 191868., 194280., 196692., 199104.,
      165849., 168306., 170763., 173220., 176298., 178764., 181230., 183696.,
      186819., 189294., 191769., 194244., 197412., 199896., 202380., 204864.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      226.,  304.,  223.,  744.,  834.,  546.,  514.,  556.,  337.,
      1396., 1474., 943.,  2094., 2184., 1356., 1144., 1186., 697.,
      2566., 2644., 1663., 3444., 3534., 2166., 1774., 1816., 1057.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474.,  564.,  1014., 1104.,
                                         1824., 1914., 2364., 2454.,
                                         3174., 3264., 3714., 3804.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      422.,  452.,  566.,  608.,  412.,  446.,  1362., 1488., 1524.,
      1668., 987.,  1092., 890.,  1028., 962.,  1112., 568.,  674.,
      2582., 2792., 2726., 2948., 1732., 1886., 3792., 4188., 3954.,
      4368., 2427., 2712., 1970., 2288., 2042., 2372., 1168., 1394.,
      4742., 5132., 4886., 5288., 3052., 3326., 6222., 6888., 6384.,
      7068., 3867., 4332., 3050., 3548., 3122., 3632., 1768., 2114.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038., 1128., 1848., 2028., 2010., 2208.,
      3306., 3648., 3468., 3828., 4278., 4728., 4440., 4908.,
      5736., 6348., 5898., 6528., 6708., 7428., 6870., 7608.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      814.,   844.,   874.,  904.,   1090.,  1132.,  1174.,  1216.,  790.,
      824.,   858.,   892.,  2598.,  2724.,  2850.,  2976.,  2904.,  3048.,
      3192.,  3336.,  1869., 1974.,  2079.,  2184.,  1642.,  1780.,  1918.,
      2056.,  1774.,  1924., 2074.,  2224.,  1030.,  1136.,  1242.,  1348.,
      4954.,  5164.,  5374., 5584.,  5230.,  5452.,  5674.,  5896.,  3310.,
      3464.,  3618.,  3772., 7188.,  7584.,  7980.,  8376.,  7494.,  7908.,
      8322.,  8736.,  4569., 4854.,  5139.,  5424.,  3622.,  3940.,  4258.,
      4576.,  3754.,  4084., 4414.,  4744.,  2110.,  2336.,  2562.,  2788.,
      9094.,  9484.,  9874., 10264., 9370.,  9772.,  10174., 10576., 5830.,
      6104.,  6378.,  6652., 11778., 12444., 13110., 13776., 12084., 12768.,
      13452., 14136., 7269., 7734.,  8199.,  8664.,  5602.,  6100.,  6598.,
      7096.,  5734.,  6244., 6754.,  7264.,  3190.,  3536.,  3882.,  4228.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1986.,  2076.,  2166.,  2256.,
      3516.,  3696.,  3876.,  4056.,  3822.,  4020.,  4218.,  4416.,
      6270.,  6612.,  6954.,  7296.,  6576.,  6936.,  7296.,  7656.,
      8106.,  8556.,  9006.,  9456.,  8412.,  8880.,  9348.,  9816.,
      10860., 11472., 12084., 12696., 11166., 11796., 12426., 13056.,
      12696., 13416., 14136., 14856., 13002., 13740., 14478., 15216.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      772.,   904.,   1060., 1216.,  780.,  892.,  2643.,  2976.,  2967.,
      3336.,  1926.,  2184., 1744.,  2056., 1888., 2224.,  1116.,  1348.,
      5092.,  5584.,  5380., 5896.,  3420., 3772., 7503.,  8376.,  7827.,
      8736.,  4806.,  5424., 3904.,  4576., 4048., 4744.,  2316.,  2788.,
      9412.,  10264., 9700., 10576., 6060., 6652., 12363., 13776., 12687.,
      14136., 7686.,  8664., 6064.,  7096., 6208., 7264.,  3516.,  4228.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1671.,  1896.,  1995.,  2256.,  3615.,  4056.,  3939.,  4416.,
      6531.,  7296.,  6855.,  7656.,  8475.,  9456.,  8799.,  9816.,
      11391., 12696., 11715., 13056., 13335., 14856., 13659., 15216.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1490.,  1544.,  1748.,  1808.,  2042.,  2120.,  2348.,  2432.,  1496.,
      1560.,  1716.,  1784.,  5043.,  5286.,  5700.,  5952.,  5655.,  5934.,
      6384.,  6672.,  3648.,  3852.,  4158.,  4368.,  3218.,  3488.,  3836.,
      4112.,  3482.,  3776.,  4148.,  4448.,  2024.,  2232.,  2484.,  2696.,
      9770.,  10184., 10748., 11168., 10322., 10760., 11348., 11792., 6536.,
      6840.,  7236.,  7544.,  14223., 15006., 15960., 16752., 14835., 15654.,
      16644., 17472., 9048.,  9612.,  10278., 10848., 7178.,  7808.,  8516.,
      9152.,  7442.,  8096.,  8828.,  9488.,  4184.,  4632.,  5124.,  5576.,
      18050., 18824., 19748., 20528., 18602., 19400., 20348., 21152., 11576.,
      12120., 12756., 13304., 23403., 24726., 26220., 27552., 24015., 25374.,
      26904., 28272., 14448., 15372., 16398., 17328., 11138., 12128., 13196.,
      14192., 11402., 12416., 13508., 14528., 6344.,  7032.,  7764.,  8456.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207.,  3342.,  3648.,  3792.,  3819.,  3990.,  4332.,  4512.,
      6879.,  7230.,  7752.,  8112.,  7491.,  7878.,  8436.,  8832.,
      12387., 13062., 13908., 14592., 12999., 13710., 14592., 15312.,
      16059., 16950., 18012., 18912., 16671., 17598., 18696., 19632.,
      21567., 22782., 24168., 25392., 22179., 23430., 24852., 26112.,
      25239., 26670., 28272., 29712., 25851., 27318., 28956., 30432.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2926.,  2980.,  3034.,  3088.,  3436.,  3496.,  3556.,  3616.,  4006.,
      4084.,  4162.,  4240.,  4612.,  4696.,  4780.,  4864.,  2928.,  2992.,
      3056.,  3120.,  3364.,  3432.,  3500.,  3568.,  9843.,  10086., 10329.,
      10572., 11148., 11400., 11652., 11904., 11031., 11310., 11589., 11868.,
      12480., 12768., 13056., 13344., 7092.,  7296.,  7500.,  7704.,  8106.,
      8316.,  8526.,  8736.,  6166.,  6436.,  6706.,  6976.,  7396.,  7672.,
      7948.,  8224.,  6670.,  6964.,  7258.,  7552.,  7996.,  8296.,  8596.,
      8896.,  3840.,  4048.,  4256.,  4464.,  4756.,  4968.,  5180.,  5392.,
      19126., 19540., 19954., 20368., 21076., 21496., 21916., 22336., 20206.,
      20644., 21082., 21520., 22252., 22696., 23140., 23584., 12768., 13072.,
      13376., 13680., 14164., 14472., 14780., 15088., 27663., 28446., 29229.,
      30012., 31128., 31920., 32712., 33504., 28851., 29670., 30489., 31308.,
      32460., 33288., 34116., 34944., 17532., 18096., 18660., 19224., 19986.,
      20556., 21126., 21696., 13726., 14356., 14986., 15616., 16396., 17032.,
      17668., 18304., 14230., 14884., 15538., 16192., 16996., 17656., 18316.,
      18976., 7920.,  8368.,  8816.,  9264.,  9796.,  10248., 10700., 11152.,
      35326., 36100., 36874., 37648., 38716., 39496., 40276., 41056., 36406.,
      37204., 38002., 38800., 39892., 40696., 41500., 42304., 22608., 23152.,
      23696., 24240., 24964., 25512., 26060., 26608., 45483., 46806., 48129.,
      49452., 51108., 52440., 53772., 55104., 46671., 48030., 49389., 50748.,
      52440., 53808., 55176., 56544., 27972., 28896., 29820., 30744., 31866.,
      32796., 33726., 34656., 21286., 22276., 23266., 24256., 25396., 26392.,
      27388., 28384., 21790., 22804., 23818., 24832., 25996., 27016., 28036.,
      29056., 12000., 12688., 13376., 14064., 14836., 15528., 16220., 16912.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6279.,  6414.,  6549.,  6684.,  7152.,  7296.,  7440.,  7584.,  7467.,
      7638.,  7809.,  7980.,  8484.,  8664.,  8844.,  9024.,  13407., 13758.,
      14109., 14460., 15144., 15504., 15864., 16224., 14595., 14982., 15369.,
      15756., 16476., 16872., 17268., 17664., 24099., 24774., 25449., 26124.,
      27132., 27816., 28500., 29184., 25287., 25998., 26709., 27420., 28464.,
      29184., 29904., 30624., 31227., 32118., 33009., 33900., 35124., 36024.,
      36924., 37824., 32415., 33342., 34269., 35196., 36456., 37392., 38328.,
      39264., 41919., 43134., 44349., 45564., 47112., 48336., 49560., 50784.,
      43107., 44358., 45609., 46860., 48444., 49704., 50964., 52224., 49047.,
      50478., 51909., 53340., 55104., 56544., 57984., 59424., 50235., 51702.,
      53169., 54636., 56436., 57912., 59388., 60864.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2842.,  3088.,  3346.,  3616.,  3946.,  4240.,  4546.,  4864.,  2908.,
      3120.,  3340.,  3568.,  9933.,  10572., 11229., 11904., 11157., 11868.,
      12597., 13344., 7206.,  7704.,  8214.,  8736.,  6370.,  6976.,  7594.,
      8224.,  6898.,  7552.,  8218.,  8896.,  4012.,  4464.,  4924.,  5392.,
      19402., 20368., 21346., 22336., 20506., 21520., 22546., 23584., 12988.,
      13680., 14380., 15088., 28293., 30012., 31749., 33504., 29517., 31308.,
      33117., 34944., 18006., 19224., 20454., 21696., 14290., 15616., 16954.,
      18304., 14818., 16192., 17578., 18976., 8332.,  9264.,  10204., 11152.,
      35962., 37648., 39346., 41056., 37066., 38800., 40546., 42304., 23068.,
      24240., 25420., 26608., 46653., 49452., 52269., 55104., 47877., 50748.,
      53637., 56544., 28806., 30744., 32694., 34656., 22210., 24256., 26314.,
      28384., 22738., 24832., 26938., 29056., 12652., 14064., 15484., 16912.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261.,  6684.,  7125.,  7584.,  7485.,  7980.,  8493.,  9024.,
      13605., 14460., 15333., 16224., 14829., 15756., 16701., 17664.,
      24621., 26124., 27645., 29184., 25845., 27420., 29013., 30624.,
      31965., 33900., 35853., 37824., 33189., 35196., 37221., 39264.,
      42981., 45564., 48165., 50784., 44205., 46860., 49533., 52224.,
      50325., 53340., 56373., 59424., 51549., 54636., 57741., 60864.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5582.,  5684.,  6068.,  6176.,   6578.,   6692.,   7112.,   7232.,
      7742.,  7892.,  8324.,  8480.,   8930.,   9092.,   9560.,   9728.,
      5692.,  5816.,  6112.,  6240.,   6548.,   6680.,   7000.,   7136.,
      19389., 19866., 20658., 21144.,  21963.,  22458.,  23304.,  23808.,
      21765., 22314., 23178., 23736.,  24627.,  25194.,  26112.,  26688.,
      14010., 14412., 15000., 15408.,  16014.,  16428.,  17052.,  17472.,
      12206., 12740., 13412., 13952.,  14642.,  15188.,  15896.,  16448.,
      13214., 13796., 14516., 15104.,  15842.,  16436.,  17192.,  17792.,
      7612.,  8024.,  8512.,  8928.,   9428.,   9848.,   10360.,  10784.,
      37982., 38804., 39908., 40736.,  41858.,  42692.,  43832.,  44672.,
      40142., 41012., 42164., 43040.,  44210.,  45092.,  46280.,  47168.,
      25372., 25976., 26752., 27360.,  28148.,  28760.,  29560.,  30176.,
      55029., 56586., 58458., 60024.,  61923.,  63498.,  65424.,  67008.,
      57405., 59034., 60978., 62616.,  64587.,  66234.,  68232.,  69888.,
      34890., 36012., 37320., 38448.,  39774.,  40908.,  42252.,  43392.,
      27326., 28580., 29972., 31232.,  32642.,  33908.,  35336.,  36608.,
      28334., 29636., 31076., 32384.,  33842.,  35156.,  36632.,  37952.,
      15772., 16664., 17632., 18528.,  19508.,  20408.,  21400.,  22304.,
      70382., 71924., 73748., 75296.,  77138.,  78692.,  80552.,  82112.,
      72542., 74132., 76004., 77600.,  79490.,  81092.,  83000.,  84608.,
      45052., 46136., 47392., 48480.,  49748.,  50840.,  52120.,  53216.,
      90669., 93306., 96258., 98904.,  101883., 104538., 107544., 110208.,
      93045., 95754., 98778., 101496., 104547., 107274., 110352., 113088.,
      55770., 57612., 59640., 61488.,  63534.,  65388.,  67452.,  69312.,
      42446., 44420., 46532., 48512.,  50642.,  52628.,  54776.,  56768.,
      43454., 45476., 47636., 49664.,  51842.,  53876.,  56072.,  58112.,
      23932., 25304., 26752., 28128.,  29588.,  30968.,  32440.,  33824.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261.,  12522.,  13098.,  13368.,  13971.,  14250.,  14880.,  15168.,
      14637.,  14970.,  15618.,  15960.,  16635.,  16986.,  17688.,  18048.,
      26517.,  27210.,  28218.,  28920.,  29955.,  30666.,  31728.,  32448.,
      28893.,  29658.,  30738.,  31512.,  32619.,  33402.,  34536.,  35328.,
      47901.,  49242.,  50898.,  52248.,  53931.,  55290.,  57000.,  58368.,
      50277.,  51690.,  53418.,  54840.,  56595.,  58026.,  59808.,  61248.,
      62157.,  63930.,  66018.,  67800.,  69915.,  71706.,  73848.,  75648.,
      64533.,  66378.,  68538.,  70392.,  72579.,  74442.,  76656.,  78528.,
      83541.,  85962.,  88698.,  91128.,  93891.,  96330.,  99120.,  101568.,
      85917.,  88410.,  91218.,  93720.,  96555.,  99066.,  101928., 104448.,
      97797.,  100650., 103818., 106680., 109875., 112746., 115968., 118848.,
      100173., 103098., 106338., 109272., 112539., 115482., 118776., 121728.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11062.,  11164.,  11266.,  11368.,  12028.,  12136.,  12244.,  12352.,
      13042.,  13156.,  13270.,  13384.,  14104.,  14224.,  14344.,  14464.,
      15334.,  15484.,  15634.,  15784.,  16492.,  16648.,  16804.,  16960.,
      17698.,  17860.,  18022.,  18184.,  18952.,  19120.,  19288.,  19456.,
      11260.,  11384.,  11508.,  11632.,  12096.,  12224.,  12352.,  12480.,
      12964.,  13096.,  13228.,  13360.,  13864.,  14000.,  14136.,  14272.,
      38301.,  38778.,  39255.,  39732.,  40830.,  41316.,  41802.,  42288.,
      43431.,  43926.,  44421.,  44916.,  46104.,  46608.,  47112.,  47616.,
      42981.,  43530.,  44079.,  44628.,  45798.,  46356.,  46914.,  47472.,
      48687.,  49254.,  49821.,  50388.,  51648.,  52224.,  52800.,  53376.,
      27618.,  28020.,  28422.,  28824.,  29592.,  30000.,  30408.,  30816.,
      31614.,  32028.,  32442.,  32856.,  33684.,  34104.,  34524.,  34944.,
      23878.,  24412.,  24946.,  25480.,  26284.,  26824.,  27364.,  27904.,
      28738.,  29284.,  29830.,  30376.,  31240.,  31792.,  32344.,  32896.,
      25846.,  26428.,  27010.,  27592.,  28444.,  29032.,  29620.,  30208.,
      31090.,  31684.,  32278.,  32872.,  33784.,  34384.,  34984.,  35584.,
      14812.,  15224.,  15636.,  16048.,  16608.,  17024.,  17440.,  17856.,
      18436.,  18856.,  19276.,  19696.,  20296.,  20720.,  21144.,  21568.,
      75142.,  75964.,  76786.,  77608.,  78988.,  79816.,  80644.,  81472.,
      82882.,  83716.,  84550.,  85384.,  86824.,  87664.,  88504.,  89344.,
      79414.,  80284.,  81154.,  82024.,  83452.,  84328.,  85204.,  86080.,
      87538.,  88420.,  89302.,  90184.,  91672.,  92560.,  93448.,  94336.,
      50140.,  50744.,  51348.,  51952.,  52896.,  53504.,  54112.,  54720.,
      55684.,  56296.,  56908.,  57520.,  58504.,  59120.,  59736.,  60352.,
      108501., 110058., 111615., 113172., 115350., 116916., 118482., 120048.,
      122271., 123846., 125421., 126996., 129264., 130848., 132432., 134016.,
      113181., 114810., 116439., 118068., 120318., 121956., 123594., 125232.,
      127527., 129174., 130821., 132468., 134808., 136464., 138120., 139776.,
      68658.,  69780.,  70902.,  72024.,  73512.,  74640.,  75768.,  76896.,
      78414.,  79548.,  80682.,  81816.,  83364.,  84504.,  85644.,  86784.,
      53398.,  54652.,  55906.,  57160.,  58684.,  59944.,  61204.,  62464.,
      64018.,  65284.,  66550.,  67816.,  69400.,  70672.,  71944.,  73216.,
      55366.,  56668.,  57970.,  59272.,  60844.,  62152.,  63460.,  64768.,
      66370.,  67684.,  68998.,  70312.,  71944.,  73264.,  74584.,  75904.,
      30652.,  31544.,  32436.,  33328.,  34368.,  35264.,  36160.,  37056.,
      38116.,  39016.,  39916.,  40816.,  41896.,  42800.,  43704.,  44608.,
      139222., 140764., 142306., 143848., 145948., 147496., 149044., 150592.,
      152722., 154276., 155830., 157384., 159544., 161104., 162664., 164224.,
      143494., 145084., 146674., 148264., 150412., 152008., 153604., 155200.,
      157378., 158980., 160582., 162184., 164392., 166000., 167608., 169216.,
      89020.,  90104.,  91188.,  92272.,  93696.,  94784.,  95872.,  96960.,
      98404.,  99496.,  100588., 101680., 103144., 104240., 105336., 106432.,
      178701., 181338., 183975., 186612., 189870., 192516., 195162., 197808.,
      201111., 203766., 206421., 209076., 212424., 215088., 217752., 220416.,
      183381., 186090., 188799., 191508., 194838., 197556., 200274., 202992.,
      206367., 209094., 211821., 214548., 217968., 220704., 223440., 226176.,
      109698., 111540., 113382., 115224., 117432., 119280., 121128., 122976.,
      125214., 127068., 128922., 130776., 133044., 134904., 136764., 138624.,
      82918.,  84892.,  86866.,  88840.,  91084.,  93064.,  95044.,  97024.,
      99298.,  101284., 103270., 105256., 107560., 109552., 111544., 113536.,
      84886.,  86908.,  88930.,  90952.,  93244.,  95272.,  97300.,  99328.,
      101650., 103684., 105718., 107752., 110104., 112144., 114184., 116224.,
      46492.,  47864.,  49236.,  50608.,  52128.,  53504.,  54880.,  56256.,
      57796.,  59176.,  60556.,  61936.,  63496.,  64880.,  66264.,  67648.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24261.,  24522.,  24783.,  25044.,  25926.,  26196.,  26466.,  26736.,
      27663.,  27942.,  28221.,  28500.,  29472.,  29760.,  30048.,  30336.,
      28941.,  29274.,  29607.,  29940.,  30894.,  31236.,  31578.,  31920.,
      32919.,  33270.,  33621.,  33972.,  35016.,  35376.,  35736.,  36096.,
      52341.,  53034.,  53727.,  54420.,  55734.,  56436.,  57138.,  57840.,
      59199.,  59910.,  60621.,  61332.,  62736.,  63456.,  64176.,  64896.,
      57021.,  57786.,  58551.,  59316.,  60702.,  61476.,  62250.,  63024.,
      64455.,  65238.,  66021.,  66804.,  68280.,  69072.,  69864.,  70656.,
      94461.,  95802.,  97143.,  98484.,  100446., 101796., 103146., 104496.,
      106503., 107862., 109221., 110580., 112632., 114000., 115368., 116736.,
      99141.,  100554., 101967., 103380., 105414., 106836., 108258., 109680.,
      111759., 113190., 114621., 116052., 118176., 119616., 121056., 122496.,
      122541., 124314., 126087., 127860., 130254., 132036., 133818., 135600.,
      138039., 139830., 141621., 143412., 145896., 147696., 149496., 151296.,
      127221., 129066., 130911., 132756., 135222., 137076., 138930., 140784.,
      143295., 145158., 147021., 148884., 151440., 153312., 155184., 157056.,
      164661., 167082., 169503., 171924., 174966., 177396., 179826., 182256.,
      185343., 187782., 190221., 192660., 195792., 198240., 200688., 203136.,
      169341., 171834., 174327., 176820., 179934., 182436., 184938., 187440.,
      190599., 193110., 195621., 198132., 201336., 203856., 206376., 208896.,
      192741., 195594., 198447., 201300., 204774., 207636., 210498., 213360.,
      216879., 219750., 222621., 225492., 229056., 231936., 234816., 237696.,
      197421., 200346., 203271., 206196., 209742., 212676., 215610., 218544.,
      222135., 225078., 228021., 230964., 234600., 237552., 240504., 243456.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      274.,  352.,  430.,  301.,  960.,  1050., 1140., 732.,  670.,
      712.,  754.,  451.,  1834., 1912., 1990., 1261., 2760., 2850.,
      2940., 1812., 1510., 1552., 1594., 931.,  3394., 3472., 3550.,
      2221., 4560., 4650., 4740., 2892., 2350., 2392., 2434., 1411.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  1320., 1410., 1500., 2400., 2490., 2580.,
      3120., 3210., 3300., 4200., 4290., 4380., 4920., 5010., 5100.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      512.,  548.,  656.,  704.,  800.,  860.,  556.,  602.,  1758.,
      1920., 1920., 2100., 2082., 2280., 1323., 1464., 1160., 1340.,
      1232., 1424., 1304., 1508., 760.,  902.,  3392., 3668., 3536.,
      3824., 3680., 3980., 2316., 2522., 4998., 5520., 5160., 5700.,
      5322., 5880., 3243., 3624., 2600., 3020., 2672., 3104., 2744.,
      3188., 1560., 1862., 6272., 6788., 6416., 6944., 6560., 7100.,
      4076., 4442., 8238., 9120., 8400., 9300., 8562., 9480., 5163.,
      5784., 4040., 4700., 4112., 4784., 4184., 4868., 2360., 2822.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110., 1200., 1272., 1380., 1434., 1560., 2406.,  2640., 2568.,
      2820., 2730., 3000., 4350., 4800., 4512., 4980.,  4674., 5160.,
      5646., 6240., 5808., 6420., 5970., 6600., 7590.,  8400., 7752.,
      8580., 7914., 8760., 8886., 9840., 9048., 10020., 9210., 10200.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      988.,   1024.,  1060.,  1096.,  1264.,  1312.,  1360.,  1408.,  1540.,
      1600.,  1660.,  1720.,  1066.,  1112.,  1158.,  1204.,  3354.,  3516.,
      3678.,  3840.,  3660.,  3840.,  4020.,  4200.,  3966.,  4164.,  4362.,
      4560.,  2505.,  2646.,  2787.,  2928.,  2140.,  2320.,  2500.,  2680.,
      2272.,  2464.,  2656.,  2848.,  2404.,  2608.,  2812.,  3016.,  1378.,
      1520.,  1662.,  1804.,  6508.,  6784.,  7060.,  7336.,  6784.,  7072.,
      7360.,  7648.,  7060.,  7360.,  7660.,  7960.,  4426.,  4632.,  4838.,
      5044.,  9474.,  9996.,  10518., 11040., 9780.,  10320., 10860., 11400.,
      10086., 10644., 11202., 11760., 6105.,  6486.,  6867.,  7248.,  4780.,
      5200.,  5620.,  6040.,  4912.,  5344.,  5776.,  6208.,  5044.,  5488.,
      5932.,  6376.,  2818.,  3120.,  3422.,  3724.,  12028., 12544., 13060.,
      13576., 12304., 12832., 13360., 13888., 12580., 13120., 13660., 14200.,
      7786.,  8152.,  8518.,  8884.,  15594., 16476., 17358., 18240., 15900.,
      16800., 17700., 18600., 16206., 17124., 18042., 18960., 9705.,  10326.,
      10947., 11568., 7420.,  8080.,  8740.,  9400.,  7552.,  8224.,  8896.,
      9568.,  7684.,  8368.,  9052.,  9736.,  4258.,  4720.,  5182.,  5644.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130.,  2220.,  2310.,  2400.,  2436.,  2544.,  2652.,  2760.,  2742.,
      2868.,  2994.,  3120.,  4578.,  4812.,  5046.,  5280.,  4884.,  5136.,
      5388.,  5640.,  5190.,  5460.,  5730.,  6000.,  8250.,  8700.,  9150.,
      9600.,  8556.,  9024.,  9492.,  9960.,  8862.,  9348.,  9834.,  10320.,
      10698., 11292., 11886., 12480., 11004., 11616., 12228., 12840., 11310.,
      11940., 12570., 13200., 14370., 15180., 15990., 16800., 14676., 15504.,
      16332., 17160., 14982., 15828., 16674., 17520., 16818., 17772., 18726.,
      19680., 17124., 18096., 19068., 20040., 17430., 18420., 19410., 20400.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      952.,   1096.,  1240.,  1408.,  1528.,  1720.,  1068.,  1204.,  3435.,
      3840.,  3759.,  4200.,  4083.,  4560.,  2598.,  2928.,  2284.,  2680.,
      2428.,  2848.,  2572.,  3016.,  1500.,  1804.,  6712.,  7336.,  7000.,
      7648.,  7288.,  7960.,  4588.,  5044.,  9915.,  11040., 10239., 11400.,
      10563., 11760., 6438.,  7248.,  5164.,  6040.,  5308.,  6208.,  5452.,
      6376.,  3100.,  3724.,  12472., 13576., 12760., 13888., 13048., 14200.,
      8108.,  8884.,  16395., 18240., 16719., 18600., 17043., 18960., 10278.,
      11568., 8044.,  9400.,  8188.,  9568.,  8332.,  9736.,  4700.,  5644.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2139.,  2400.,  2463.,  2760.,  2787.,  3120.,  4731.,  5280.,  5055.,
      5640.,  5379.,  6000.,  8619.,  9600.,  8943.,  9960.,  9267.,  10320.,
      11211., 12480., 11535., 12840., 11859., 13200., 15099., 16800., 15423.,
      17160., 15747., 17520., 17691., 19680., 18015., 20040., 18339., 20400.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1838.,  1904.,  2120.,  2192.,  2390.,  2480.,  2720.,  2816.,  2942.,
      3056.,  3320.,  3440.,  2048.,  2136.,  2316.,  2408.,  6555.,  6870.,
      7356.,  7680.,  7167.,  7518.,  8040.,  8400.,  7779.,  8166.,  8724.,
      9120.,  4920.,  5196.,  5574.,  5856.,  4214.,  4568.,  5000.,  5360.,
      4478.,  4856.,  5312.,  5696.,  4742.,  5144.,  5624.,  6032.,  2720.,
      3000.,  3324.,  3608.,  12878., 13424., 14120., 14672., 13430., 14000.,
      14720., 15296., 13982., 14576., 15320., 15920., 8768.,  9176.,  9676.,
      10088., 18795., 19830., 21036., 22080., 19407., 20478., 21720., 22800.,
      20019., 21126., 22404., 23520., 12120., 12876., 13734., 14496., 9494.,
      10328., 11240., 12080., 9758.,  10616., 11552., 12416., 10022., 10904.,
      11864., 12752., 5600.,  6200.,  6844.,  7448.,  23918., 24944., 26120.,
      27152., 24470., 25520., 26720., 27776., 25022., 26096., 27320., 28400.,
      15488., 16216., 17036., 17768., 31035., 32790., 34716., 36480., 31647.,
      33438., 35400., 37200., 32259., 34086., 36084., 37920., 19320., 20556.,
      21894., 23136., 14774., 16088., 17480., 18800., 15038., 16376., 17792.,
      19136., 15302., 16664., 18104., 19472., 8480.,  9400.,  10364., 11288.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107.,  4278.,  4620.,  4800.,  4719.,  4926.,  5304.,  5520.,  5331.,
      5574.,  5988.,  6240.,  9003.,  9462.,  10092., 10560., 9615.,  10110.,
      10776., 11280., 10227., 10758., 11460., 12000., 16347., 17238., 18300.,
      19200., 16959., 17886., 18984., 19920., 17571., 18534., 19668., 20640.,
      21243., 22422., 23772., 24960., 21855., 23070., 24456., 25680., 22467.,
      23718., 25140., 26400., 28587., 30198., 31980., 33600., 29199., 30846.,
      32664., 34320., 29811., 31494., 33348., 35040., 33483., 35382., 37452.,
      39360., 34095., 36030., 38136., 40080., 34707., 36678., 38820., 40800.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3610.,  3676.,  3742.,  3808.,  4168.,  4240.,  4312.,  4384.,  4690.,
      4780.,  4870.,  4960.,  5344.,  5440.,  5536.,  5632.,  5770.,  5884.,
      5998.,  6112.,  6520.,  6640.,  6760.,  6880.,  4008.,  4096.,  4184.,
      4272.,  4540.,  4632.,  4724.,  4816.,  12795., 13110., 13425., 13740.,
      14388., 14712., 15036., 15360., 13983., 14334., 14685., 15036., 15720.,
      16080., 16440., 16800., 15171., 15558., 15945., 16332., 17052., 17448.,
      17844., 18240., 9564.,  9840.,  10116., 10392., 10866., 11148., 11430.,
      11712., 8074.,  8428.,  8782.,  9136.,  9640.,  10000., 10360., 10720.,
      8578.,  8956.,  9334.,  9712.,  10240., 10624., 11008., 11392., 9082.,
      9484.,  9886.,  10288., 10840., 11248., 11656., 12064., 5160.,  5440.,
      5720.,  6000.,  6364.,  6648.,  6932.,  7216.,  25210., 25756., 26302.,
      26848., 27688., 28240., 28792., 29344., 26290., 26860., 27430., 28000.,
      28864., 29440., 30016., 30592., 27370., 27964., 28558., 29152., 30040.,
      30640., 31240., 31840., 17128., 17536., 17944., 18352., 18940., 19352.,
      19764., 20176., 36555., 37590., 38625., 39660., 41028., 42072., 43116.,
      44160., 37743., 38814., 39885., 40956., 42360., 43440., 44520., 45600.,
      38931., 40038., 41145., 42252., 43692., 44808., 45924., 47040., 23484.,
      24240., 24996., 25752., 26706., 27468., 28230., 28992., 18154., 18988.,
      19822., 20656., 21640., 22480., 23320., 24160., 18658., 19516., 20374.,
      21232., 22240., 23104., 23968., 24832., 19162., 20044., 20926., 21808.,
      22840., 23728., 24616., 25504., 10600., 11200., 11800., 12400., 13084.,
      13688., 14292., 14896., 46810., 47836., 48862., 49888., 51208., 52240.,
      53272., 54304., 47890., 48940., 49990., 51040., 52384., 53440., 54496.,
      55552., 48970., 50044., 51118., 52192., 53560., 54640., 55720., 56800.,
      30248., 30976., 31704., 32432., 33340., 34072., 34804., 35536., 60315.,
      62070., 63825., 65580., 67668., 69432., 71196., 72960., 61503., 63294.,
      65085., 66876., 69000., 70800., 72600., 74400., 62691., 64518., 66345.,
      68172., 70332., 72168., 74004., 75840., 37404., 38640., 39876., 41112.,
      42546., 43788., 45030., 46272., 28234., 29548., 30862., 32176., 33640.,
      34960., 36280., 37600., 28738., 30076., 31414., 32752., 34240., 35584.,
      36928., 38272., 29242., 30604., 31966., 33328., 34840., 36208., 37576.,
      38944., 16040., 16960., 17880., 18800., 19804., 20728., 21652., 22576.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8043.,  8214.,  8385.,  8556.,  9060.,  9240.,  9420.,  9600.,  9231.,
      9438.,  9645.,  9852.,  10392., 10608., 10824., 11040., 10419., 10662.,
      10905., 11148., 11724., 11976., 12228., 12480., 17547., 18006., 18465.,
      18924., 19716., 20184., 20652., 21120., 18735., 19230., 19725., 20220.,
      21048., 21552., 22056., 22560., 19923., 20454., 20985., 21516., 22380.,
      22920., 23460., 24000., 31803., 32694., 33585., 34476., 35700., 36600.,
      37500., 38400., 32991., 33918., 34845., 35772., 37032., 37968., 38904.,
      39840., 34179., 35142., 36105., 37068., 38364., 39336., 40308., 41280.,
      41307., 42486., 43665., 44844., 46356., 47544., 48732., 49920., 42495.,
      43710., 44925., 46140., 47688., 48912., 50136., 51360., 43683., 44934.,
      46185., 47436., 49020., 50280., 51540., 52800., 55563., 57174., 58785.,
      60396., 62340., 63960., 65580., 67200., 56751., 58398., 60045., 61692.,
      63672., 65328., 66984., 68640., 57939., 59622., 61305., 62988., 65004.,
      66696., 68388., 70080., 65067., 66966., 68865., 70764., 72996., 74904.,
      76812., 78720., 66255., 68190., 70125., 72060., 74328., 76272., 78216.,
      80160., 67443., 69414., 71385., 73356., 75660., 77640., 79620., 81600.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3538.,  3808.,  4090.,  4384.,  4642.,  4960.,  5290.,  5632.,  5746.,
      6112.,  6490.,  6880.,  4012.,  4272.,  4540.,  4816.,  12957., 13740.,
      14541., 15360., 14181., 15036., 15909., 16800., 15405., 16332., 17277.,
      18240., 9750.,  10392., 11046., 11712., 8362.,  9136.,  9922.,  10720.,
      8890.,  9712.,  10546., 11392., 9418.,  10288., 11170., 12064., 5404.,
      6000.,  6604.,  7216.,  25618., 26848., 28090., 29344., 26722., 28000.,
      29290., 30592., 27826., 29152., 30490., 31840., 17452., 18352., 19260.,
      20176., 37437., 39660., 41901., 44160., 38661., 40956., 43269., 45600.,
      39885., 42252., 44637., 47040., 24150., 25752., 27366., 28992., 18922.,
      20656., 22402., 24160., 19450., 21232., 23026., 24832., 19978., 21808.,
      23650., 25504., 11164., 12400., 13644., 14896., 47698., 49888., 52090.,
      54304., 48802., 51040., 53290., 55552., 49906., 52192., 54490., 56800.,
      30892., 32432., 33980., 35536., 61917., 65580., 69261., 72960., 63141.,
      66876., 70629., 74400., 64365., 68172., 71997., 75840., 38550., 41112.,
      43686., 46272., 29482., 32176., 34882., 37600., 30010., 32752., 35506.,
      38272., 30538., 33328., 36130., 38944., 16924., 18800., 20684., 22576.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,  8556.,  9069.,  9600.,  9285.,  9852.,  10437., 11040., 10509.,
      11148., 11805., 12480., 17853., 18924., 20013., 21120., 19077., 20220.,
      21381., 22560., 20301., 21516., 22749., 24000., 32541., 34476., 36429.,
      38400., 33765., 35772., 37797., 39840., 34989., 37068., 39165., 41280.,
      42333., 44844., 47373., 49920., 43557., 46140., 48741., 51360., 44781.,
      47436., 50109., 52800., 57021., 60396., 63789., 67200., 58245., 61692.,
      65157., 68640., 59469., 62988., 66525., 70080., 66813., 70764., 74733.,
      78720., 68037., 72060., 76101., 80160., 69261., 73356., 77469., 81600.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6950.,   7076.,   7484.,   7616.,   8042.,   8180.,   8624.,   8768.,
      9110.,   9284.,   9740.,   9920.,   10394.,  10580.,  11072.,  11264.,
      11270.,  11492.,  11996.,  12224.,  12746.,  12980.,  13520.,  13760.,
      7852.,   8024.,   8368.,   8544.,   8900.,   9080.,   9448.,   9632.,
      25293.,  25914.,  26850.,  27480.,  28443.,  29082.,  30072.,  30720.,
      27669.,  28362.,  29370.,  30072.,  31107.,  31818.,  32880.,  33600.,
      30045.,  30810.,  31890.,  32664.,  33771.,  34554.,  35688.,  36480.,
      18954.,  19500.,  20232.,  20784.,  21534.,  22092.,  22860.,  23424.,
      16022.,  16724.,  17564.,  18272.,  19130.,  19844.,  20720.,  21440.,
      17030.,  17780.,  18668.,  19424.,  20330.,  21092.,  22016.,  22784.,
      18038.,  18836.,  19772.,  20576.,  21530.,  22340.,  23312.,  24128.,
      10252.,  10808.,  11440.,  12000.,  12644.,  13208.,  13864.,  14432.,
      50150.,  51236.,  52604.,  53696.,  55082.,  56180.,  57584.,  58688.,
      52310.,  53444.,  54860.,  56000.,  57434.,  58580.,  60032.,  61184.,
      54470.,  55652.,  57116.,  58304.,  59786.,  60980.,  62480.,  63680.,
      34092.,  34904.,  35888.,  36704.,  37700.,  38520.,  39528.,  40352.,
      72813.,  74874.,  77250.,  79320.,  81723.,  83802.,  86232.,  88320.,
      75189.,  77322.,  79770.,  81912.,  84387.,  86538.,  89040.,  91200.,
      77565.,  79770.,  82290.,  84504.,  87051.,  89274.,  91848.,  94080.,
      46794.,  48300.,  49992.,  51504.,  53214.,  54732.,  56460.,  57984.,
      36182.,  37844.,  39644.,  41312.,  43130.,  44804.,  46640.,  48320.,
      37190.,  38900.,  40748.,  42464.,  44330.,  46052.,  47936.,  49664.,
      38198.,  39956.,  41852.,  43616.,  45530.,  47300.,  49232.,  51008.,
      21132.,  22328.,  23600.,  24800.,  26084.,  27288.,  28584.,  29792.,
      93350.,  95396.,  97724.,  99776.,  102122., 104180., 106544., 108608.,
      95510.,  97604.,  99980.,  102080., 104474., 106580., 108992., 111104.,
      97670.,  99812.,  102236., 104384., 106826., 108980., 111440., 113600.,
      60332.,  61784.,  63408.,  64864.,  66500.,  67960.,  69608.,  71072.,
      120333., 123834., 127650., 131160., 135003., 138522., 142392., 145920.,
      122709., 126282., 130170., 133752., 137667., 141258., 145200., 148800.,
      125085., 128730., 132690., 136344., 140331., 143994., 148008., 151680.,
      74634.,  77100.,  79752.,  82224.,  84894.,  87372.,  90060.,  92544.,
      56342.,  58964.,  61724.,  64352.,  67130.,  69764.,  72560.,  75200.,
      57350.,  60020.,  62828.,  65504.,  68330.,  71012.,  73856.,  76544.,
      58358.,  61076.,  63932.,  66656.,  69530.,  72260.,  75152.,  77888.,
      32012.,  33848.,  35760.,  37600.,  39524.,  41368.,  43304.,  45152.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789.,  16122.,  16770.,  17112.,  17787.,  18138.,  18840.,  19200.,
      18165.,  18570.,  19290.,  19704.,  20451.,  20874.,  21648.,  22080.,
      20541.,  21018.,  21810.,  22296.,  23115.,  23610.,  24456.,  24960.,
      34797.,  35706.,  36930.,  37848.,  39099.,  40026.,  41304.,  42240.,
      37173.,  38154.,  39450.,  40440.,  41763.,  42762.,  44112.,  45120.,
      39549.,  40602.,  41970.,  43032.,  44427.,  45498.,  46920.,  48000.,
      63309.,  65082.,  67170.,  68952.,  71067.,  72858.,  75000.,  76800.,
      65685.,  67530.,  69690.,  71544.,  73731.,  75594.,  77808.,  79680.,
      68061.,  69978.,  72210.,  74136.,  76395.,  78330.,  80616.,  82560.,
      82317.,  84666.,  87330.,  89688.,  92379.,  94746.,  97464.,  99840.,
      84693.,  87114.,  89850.,  92280.,  95043.,  97482.,  100272., 102720.,
      87069.,  89562.,  92370.,  94872.,  97707.,  100218., 103080., 105600.,
      110829., 114042., 117570., 120792., 124347., 127578., 131160., 134400.,
      113205., 116490., 120090., 123384., 127011., 130314., 133968., 137280.,
      115581., 118938., 122610., 125976., 129675., 133050., 136776., 140160.,
      129837., 133626., 137730., 141528., 145659., 149466., 153624., 157440.,
      132213., 136074., 140250., 144120., 148323., 152202., 156432., 160320.,
      134589., 138522., 142770., 146712., 150987., 154938., 159240., 163200.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13774.,  13900.,  14026.,  14152.,  14836.,  14968.,  15100.,  15232.,
      15946.,  16084.,  16222.,  16360.,  17104.,  17248.,  17392.,  17536.,
      18046.,  18220.,  18394.,  18568.,  19300.,  19480.,  19660.,  19840.,
      20602.,  20788.,  20974.,  21160.,  21952.,  22144.,  22336.,  22528.,
      22318.,  22540.,  22762.,  22984.,  23764.,  23992.,  24220.,  24448.,
      25258.,  25492.,  25726.,  25960.,  26800.,  27040.,  27280.,  27520.,
      15532.,  15704.,  15876.,  16048.,  16560.,  16736.,  16912.,  17088.,
      17620.,  17800.,  17980.,  18160.,  18712.,  18896.,  19080.,  19264.,
      49965.,  50586.,  51207.,  51828.,  53070.,  53700.,  54330.,  54960.,
      56247.,  56886.,  57525.,  58164.,  59496.,  60144.,  60792.,  61440.,
      54645.,  55338.,  56031.,  56724.,  58038.,  58740.,  59442.,  60144.,
      61503.,  62214.,  62925.,  63636.,  65040.,  65760.,  66480.,  67200.,
      59325.,  60090.,  60855.,  61620.,  63006.,  63780.,  64554.,  65328.,
      66759.,  67542.,  68325.,  69108.,  70584.,  71376.,  72168.,  72960.,
      37362.,  37908.,  38454.,  39000.,  39912.,  40464.,  41016.,  41568.,
      42510.,  43068.,  43626.,  44184.,  45156.,  45720.,  46284.,  46848.,
      31342.,  32044.,  32746.,  33448.,  34420.,  35128.,  35836.,  36544.,
      37546.,  38260.,  38974.,  39688.,  40720.,  41440.,  42160.,  42880.,
      33310.,  34060.,  34810.,  35560.,  36580.,  37336.,  38092.,  38848.,
      39898.,  40660.,  41422.,  42184.,  43264.,  44032.,  44800.,  45568.,
      35278.,  36076.,  36874.,  37672.,  38740.,  39544.,  40348.,  41152.,
      42250.,  43060.,  43870.,  44680.,  45808.,  46624.,  47440.,  48256.,
      19948.,  20504.,  21060.,  21616.,  22320.,  22880.,  23440.,  24000.,
      24724.,  25288.,  25852.,  26416.,  27160.,  27728.,  28296.,  28864.,
      99214.,  100300., 101386., 102472., 104116., 105208., 106300., 107392.,
      109066., 110164., 111262., 112360., 114064., 115168., 116272., 117376.,
      103486., 104620., 105754., 106888., 108580., 109720., 110860., 112000.,
      113722., 114868., 116014., 117160., 118912., 120064., 121216., 122368.,
      107758., 108940., 110122., 111304., 113044., 114232., 115420., 116608.,
      118378., 119572., 120766., 121960., 123760., 124960., 126160., 127360.,
      67372.,  68184.,  68996.,  69808.,  70960.,  71776.,  72592.,  73408.,
      74580.,  75400.,  76220.,  77040.,  78232.,  79056.,  79880.,  80704.,
      143565., 145626., 147687., 149748., 152430., 154500., 156570., 158640.,
      161367., 163446., 165525., 167604., 170376., 172464., 174552., 176640.,
      148245., 150378., 152511., 154644., 157398., 159540., 161682., 163824.,
      166623., 168774., 170925., 173076., 175920., 178080., 180240., 182400.,
      152925., 155130., 157335., 159540., 162366., 164580., 166794., 169008.,
      171879., 174102., 176325., 178548., 181464., 183696., 185928., 188160.,
      92082.,  93588.,  95094.,  96600.,  98472.,  99984.,  101496., 103008.,
      104910., 106428., 107946., 109464., 111396., 112920., 114444., 115968.,
      70702.,  72364.,  74026.,  75688.,  77620.,  79288.,  80956.,  82624.,
      84586.,  86260.,  87934.,  89608.,  91600.,  93280.,  94960.,  96640.,
      72670.,  74380.,  76090.,  77800.,  79780.,  81496.,  83212.,  84928.,
      86938.,  88660.,  90382.,  92104.,  94144.,  95872.,  97600.,  99328.,
      74638.,  76396.,  78154.,  79912.,  81940.,  83704.,  85468.,  87232.,
      89290.,  91060.,  92830.,  94600.,  96688.,  98464.,  100240., 102016.,
      41068.,  42264.,  43460.,  44656.,  46000.,  47200.,  48400.,  49600.,
      50964.,  52168.,  53372.,  54576.,  55960.,  57168.,  58376.,  59584.,
      184654., 186700., 188746., 190792., 193396., 195448., 197500., 199552.,
      202186., 204244., 206302., 208360., 211024., 213088., 215152., 217216.,
      188926., 191020., 193114., 195208., 197860., 199960., 202060., 204160.,
      206842., 208948., 211054., 213160., 215872., 217984., 220096., 222208.,
      193198., 195340., 197482., 199624., 202324., 204472., 206620., 208768.,
      211498., 213652., 215806., 217960., 220720., 222880., 225040., 227200.,
      119212., 120664., 122116., 123568., 125360., 126816., 128272., 129728.,
      131540., 133000., 134460., 135920., 137752., 139216., 140680., 142144.,
      237165., 240666., 244167., 247668., 251790., 255300., 258810., 262320.,
      266487., 270006., 273525., 277044., 281256., 284784., 288312., 291840.,
      241845., 245418., 248991., 252564., 256758., 260340., 263922., 267504.,
      271743., 275334., 278925., 282516., 286800., 290400., 294000., 297600.,
      246525., 250170., 253815., 257460., 261726., 265380., 269034., 272688.,
      276999., 280662., 284325., 287988., 292344., 296016., 299688., 303360.,
      146802., 149268., 151734., 154200., 157032., 159504., 161976., 164448.,
      167310., 169788., 172266., 174744., 177636., 180120., 182604., 185088.,
      110062., 112684., 115306., 117928., 120820., 123448., 126076., 128704.,
      131626., 134260., 136894., 139528., 142480., 145120., 147760., 150400.,
      112030., 114700., 117370., 120040., 122980., 125656., 128332., 131008.,
      133978., 136660., 139342., 142024., 145024., 147712., 150400., 153088.,
      113998., 116716., 119434., 122152., 125140., 127864., 130588., 133312.,
      136330., 139060., 141790., 144520., 147568., 150304., 153040., 155776.,
      62188.,  64024.,  65860.,  67696.,  69680.,  71520.,  73360.,  75200.,
      77204.,  79048.,  80892.,  82736.,  84760.,  86608.,  88456.,  90304.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31245.,  31578.,  31911.,  32244.,  33198.,  33540.,  33882.,  34224.,
      35223.,  35574.,  35925.,  36276.,  37320.,  37680.,  38040.,  38400.,
      35925.,  36330.,  36735.,  37140.,  38166.,  38580.,  38994.,  39408.,
      40479.,  40902.,  41325.,  41748.,  42864.,  43296.,  43728.,  44160.,
      40605.,  41082.,  41559.,  42036.,  43134.,  43620.,  44106.,  44592.,
      45735.,  46230.,  46725.,  47220.,  48408.,  48912.,  49416.,  49920.,
      68685.,  69594.,  70503.,  71412.,  72942.,  73860.,  74778.,  75696.,
      77271.,  78198.,  79125.,  80052.,  81672.,  82608.,  83544.,  84480.,
      73365.,  74346.,  75327.,  76308.,  77910.,  78900.,  79890.,  80880.,
      82527.,  83526.,  84525.,  85524.,  87216.,  88224.,  89232.,  90240.,
      78045.,  79098.,  80151.,  81204.,  82878.,  83940.,  85002.,  86064.,
      87783.,  88854.,  89925.,  90996.,  92760.,  93840.,  94920.,  96000.,
      124845., 126618., 128391., 130164., 132558., 134340., 136122., 137904.,
      140343., 142134., 143925., 145716., 148200., 150000., 151800., 153600.,
      129525., 131370., 133215., 135060., 137526., 139380., 141234., 143088.,
      145599., 147462., 149325., 151188., 153744., 155616., 157488., 159360.,
      134205., 136122., 138039., 139956., 142494., 144420., 146346., 148272.,
      150855., 152790., 154725., 156660., 159288., 161232., 163176., 165120.,
      162285., 164634., 166983., 169332., 172302., 174660., 177018., 179376.,
      182391., 184758., 187125., 189492., 192552., 194928., 197304., 199680.,
      166965., 169386., 171807., 174228., 177270., 179700., 182130., 184560.,
      187647., 190086., 192525., 194964., 198096., 200544., 202992., 205440.,
      171645., 174138., 176631., 179124., 182238., 184740., 187242., 189744.,
      192903., 195414., 197925., 200436., 203640., 206160., 208680., 211200.,
      218445., 221658., 224871., 228084., 231918., 235140., 238362., 241584.,
      245463., 248694., 251925., 255156., 259080., 262320., 265560., 268800.,
      223125., 226410., 229695., 232980., 236886., 240180., 243474., 246768.,
      250719., 254022., 257325., 260628., 264624., 267936., 271248., 274560.,
      227805., 231162., 234519., 237876., 241854., 245220., 248586., 251952.,
      255975., 259350., 262725., 266100., 270168., 273552., 276936., 280320.,
      255885., 259674., 263463., 267252., 271662., 275460., 279258., 283056.,
      287511., 291318., 295125., 298932., 303432., 307248., 311064., 314880.,
      260565., 264426., 268287., 272148., 276630., 280500., 284370., 288240.,
      292767., 296646., 300525., 304404., 308976., 312864., 316752., 320640.,
      265245., 269178., 273111., 277044., 281598., 285540., 289482., 293424.,
      298023., 301974., 305925., 309876., 314520., 318480., 322440., 326400.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      276.,  456.,  318.,  606.,  906.,  588.,  400.,  562.,  340.,
      1266., 1806., 1128., 1596., 2256., 1398., 880.,  1192., 700.,
      2256., 3156., 1938., 2586., 3606., 2208., 1360., 1822., 1060.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411.,  501.,  861.,  951.,
                                         1761., 1851., 2211., 2301.,
                                         3111., 3201., 3561., 3651.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      513.,  552.,  840.,  912.,  579.,  636.,  1113., 1212., 1650.,
      1812., 1059., 1176., 704.,  800.,  971.,  1124., 572.,  680.,
      2313., 2532., 3270., 3612., 2019., 2256., 2913., 3192., 4080.,
      4512., 2499., 2796., 1544., 1760., 2051., 2384., 1172., 1400.,
      4113., 4512., 5700., 6312., 3459., 3876., 4713., 5172., 6510.,
      7212., 3939., 4416., 2384., 2720., 3131., 3644., 1772., 2120.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  921.,  1002., 1569., 1722., 1731., 1902.,
      3189., 3522., 3351., 3702., 3999., 4422., 4161., 4602.,
      5619., 6222., 5781., 6402., 6429., 7122., 6591., 7302.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      987.,   1026.,  1065., 1104., 1608.,  1680.,  1752.,  1824.,  1101.,
      1158.,  1215.,  1272., 2127., 2226.,  2325.,  2424.,  3138.,  3300.,
      3462.,  3624.,  2001., 2118., 2235.,  2352.,  1312.,  1408.,  1504.,
      1600.,  1789.,  1942., 2095., 2248.,  1036.,  1144.,  1252.,  1360.,
      4407.,  4626.,  4845., 5064., 6198.,  6540.,  6882.,  7224.,  3801.,
      4038.,  4275.,  4512., 5547., 5826.,  6105.,  6384.,  7728.,  8160.,
      8592.,  9024.,  4701., 4998., 5295.,  5592.,  2872.,  3088.,  3304.,
      3520.,  3769.,  4102., 4435., 4768.,  2116.,  2344.,  2572.,  2800.,
      7827.,  8226.,  8625., 9024., 10788., 11400., 12012., 12624., 6501.,
      6918.,  7335.,  7752., 8967., 9426.,  9885.,  10344., 12318., 13020.,
      13722., 14424., 7401., 7878., 8355.,  8832.,  4432.,  4768.,  5104.,
      5440.,  5749.,  6262., 6775., 7288.,  3196.,  3544.,  3892.,  4240.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455.,  1518.,  1581.,  1644.,  1761.,  1842.,  1923.,  2004.,
      2985.,  3138.,  3291.,  3444.,  3291.,  3462.,  3633.,  3804.,
      6045.,  6378.,  6711.,  7044.,  6351.,  6702.,  7053.,  7404.,
      7575.,  7998.,  8421.,  8844.,  7881.,  8322.,  8763.,  9204.,
      10635., 11238., 11841., 12444., 10941., 11562., 12183., 12804.,
      12165., 12858., 13551., 14244., 12471., 13182., 13893., 14604.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      966.,   1104., 1599.,  1824.,  1110., 1272., 2166., 2424.,  3219.,
      3624.,  2070., 2352.,  1380.,  1600., 1906., 2248., 1124.,  1360.,
      4566.,  5064., 6459.,  7224.,  3990., 4512., 5766., 6384.,  8079.,
      9024.,  4950., 5592.,  3060.,  3520., 4066., 4768., 2324.,  2800.,
      8166.,  9024., 11319., 12624., 6870., 7752., 9366., 10344., 12939.,
      14424., 7830., 8832.,  4740.,  5440., 6226., 7288., 3524.,  4240.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1437.,  1644.,  1761.,  2004.,  3057.,  3444.,  3381.,  3804.,
      6297.,  7044.,  6621.,  7404.,  7917.,  8844.,  8241.,  9204.,
      11157., 12444., 11481., 12804., 12777., 14244., 13101., 14604.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1860.,  1932.,  2130.,  2208.,  3063.,  3198.,  3504.,  3648.,  2112.,
      2220.,  2430.,  2544.,  4140.,  4332.,  4650.,  4848.,  6123.,  6438.,
      6924.,  7248.,  3912.,  4140.,  4470.,  4704.,  2572.,  2760.,  3008.,
      3200.,  3512.,  3812.,  4190.,  4496.,  2036.,  2248.,  2504.,  2720.,
      8700.,  9132.,  9690.,  10128., 12243., 12918., 13764., 14448., 7512.,
      7980.,  8550.,  9024.,  10980., 11532., 12210., 12768., 15303., 16158.,
      17184., 18048., 9312.,  9900.,  10590., 11184., 5692.,  6120.,  6608.,
      7040.,  7472.,  8132.,  8870.,  9536.,  4196.,  4648.,  5144.,  5600.,
      15540., 16332., 17250., 18048., 21423., 22638., 24024., 25248., 12912.,
      13740., 14670., 15504., 17820., 18732., 19770., 20688., 24483., 25878.,
      27444., 28848., 14712., 15660., 16710., 17664., 8812.,  9480.,  10208.,
      10880., 11432., 12452., 13550., 14576., 6356.,  7048.,  7784.,  8480.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2757.,  2874.,  3162.,  3288.,  3369.,  3522.,  3846.,  4008.,
      5817.,  6114.,  6582.,  6888.,  6429.,  6762.,  7266.,  7608.,
      11937., 12594., 13422., 14088., 12549., 13242., 14106., 14808.,
      14997., 15834., 16842., 17688., 15609., 16482., 17526., 18408.,
      21117., 22314., 23682., 24888., 21729., 22962., 24366., 25608.,
      24177., 25554., 27102., 28488., 24789., 26202., 27786., 29208.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3648.,  3720.,  3792.,  3864.,  4182.,  4260.,  4338.,  4416.,  5991.,
      6126.,  6261.,  6396.,  6864.,  7008.,  7152.,  7296.,  4116.,  4224.,
      4332.,  4440.,  4746.,  4860.,  4974.,  5088.,  8088.,  8280.,  8472.,
      8664.,  9102.,  9300.,  9498.,  9696.,  11931., 12246., 12561., 12876.,
      13524., 13848., 14172., 14496., 7596.,  7824.,  8052.,  8280.,  8706.,
      8940.,  9174.,  9408.,  4956.,  5144.,  5332.,  5520.,  5824.,  6016.,
      6208.,  6400.,  6724.,  7024.,  7324.,  7624.,  8074.,  8380.,  8686.,
      8992.,  3860.,  4072.,  4284.,  4496.,  4792.,  5008.,  5224.,  5440.,
      16968., 17400., 17832., 18264., 18942., 19380., 19818., 20256., 23811.,
      24486., 25161., 25836., 26844., 27528., 28212., 28896., 14556., 15024.,
      15492., 15960., 16626., 17100., 17574., 18048., 21408., 21960., 22512.,
      23064., 23862., 24420., 24978., 25536., 29751., 30606., 31461., 32316.,
      33504., 34368., 35232., 36096., 18036., 18624., 19212., 19800., 20586.,
      21180., 21774., 22368., 10956., 11384., 11812., 12240., 12784., 13216.,
      13648., 14080., 14284., 14944., 15604., 16264., 17074., 17740., 18406.,
      19072., 7940.,  8392.,  8844.,  9296.,  9832.,  10288., 10744., 11200.,
      30288., 31080., 31872., 32664., 33702., 34500., 35298., 36096., 41631.,
      42846., 44061., 45276., 46824., 48048., 49272., 50496., 24996., 25824.,
      26652., 27480., 28506., 29340., 30174., 31008., 34728., 35640., 36552.,
      37464., 38622., 39540., 40458., 41376., 47571., 48966., 50361., 51756.,
      53484., 54888., 56292., 57696., 28476., 29424., 30372., 31320., 32466.,
      33420., 34374., 35328., 16956., 17624., 18292., 18960., 19744., 20416.,
      21088., 21760., 21844., 22864., 23884., 24904., 26074., 27100., 28126.,
      29152., 12020., 12712., 13404., 14096., 14872., 15568., 16264., 16960.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5397.,  5514.,  5631.,  5748.,  6198.,  6324.,  6450.,  6576.,  6585.,
      6738.,  6891.,  7044.,  7530.,  7692.,  7854.,  8016.,  11337., 11634.,
      11931., 12228., 12858., 13164., 13470., 13776., 12525., 12858., 13191.,
      13524., 14190., 14532., 14874., 15216., 23217., 23874., 24531., 25188.,
      26178., 26844., 27510., 28176., 24405., 25098., 25791., 26484., 27510.,
      28212., 28914., 29616., 29157., 29994., 30831., 31668., 32838., 33684.,
      34530., 35376., 30345., 31218., 32091., 32964., 34170., 35052., 35934.,
      36816., 41037., 42234., 43431., 44628., 46158., 47364., 48570., 49776.,
      42225., 43458., 44691., 45924., 47490., 48732., 49974., 51216., 46977.,
      48354., 49731., 51108., 52818., 54204., 55590., 56976., 48165., 49578.,
      50991., 52404., 54150., 55572., 56994., 58416.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3606.,  3864.,  4134.,  4416.,  5973.,  6396.,  6837.,  7296.,  4134.,
      4440.,  4758.,  5088.,  8166.,  8664.,  9174.,  9696.,  12093., 12876.,
      13677., 14496., 7734.,  8280.,  8838.,  9408.,  5092.,  5520.,  5956.,
      6400.,  6958.,  7624.,  8302.,  8992.,  4036.,  4496.,  4964.,  5440.,
      17286., 18264., 19254., 20256., 24333., 25836., 27357., 28896., 14934.,
      15960., 16998., 18048., 21846., 23064., 24294., 25536., 30453., 32316.,
      34197., 36096., 18534., 19800., 21078., 22368., 11332., 12240., 13156.,
      14080., 14878., 16264., 17662., 19072., 8356.,  9296.,  10244., 11200.,
      30966., 32664., 34374., 36096., 42693., 45276., 47877., 50496., 25734.,
      27480., 29238., 31008., 35526., 37464., 39414., 41376., 48813., 51756.,
      54717., 57696., 29334., 31320., 33318., 35328., 17572., 18960., 20356.,
      21760., 22798., 24904., 27022., 29152., 12676., 14096., 15524., 16960.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5361.,  5748.,  6153.,  6576.,  6585.,  7044.,  7521.,  8016.,
      11481., 12228., 12993., 13776., 12705., 13524., 14361., 15216.,
      23721., 25188., 26673., 28176., 24945., 26484., 28041., 29616.,
      29841., 31668., 33513., 35376., 31065., 32964., 34881., 36816.,
      42081., 44628., 47193., 49776., 43305., 45924., 48561., 51216.,
      48201., 51108., 54033., 56976., 49425., 52404., 55401., 58416.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7074.,  7212.,  7584.,   7728.,   8118.,   8268.,   8676.,   8832.,
      11685., 11946., 12522.,  12792.,  13395.,  13674.,  14304.,  14592.,
      8058.,  8268.,  8664.,   8880.,   9294.,   9516.,   9948.,   10176.,
      15954., 16332., 16944.,  17328.,  17958.,  18348.,  18996.,  19392.,
      23565., 24186., 25122.,  25752.,  26715.,  27354.,  28344.,  28992.,
      15018., 15468., 16104.,  16560.,  17214.,  17676.,  18348.,  18816.,
      9812.,  10184., 10664.,  11040.,  11532.,  11912.,  12416.,  12800.,
      13322., 13916., 14648.,  15248.,  15998.,  16604.,  17372.,  17984.,
      7652.,  8072.,  8568.,   8992.,   9500.,   9928.,   10448.,  10880.,
      33714., 34572., 35664.,  36528.,  37638.,  38508.,  39636.,  40512.,
      47325., 48666., 50322.,  51672.,  53355.,  54714.,  56424.,  57792.,
      28938., 29868., 30984.,  31920.,  33054.,  33996.,  35148.,  36096.,
      42594., 43692., 45024.,  46128.,  47478.,  48588.,  49956.,  51072.,
      59205., 60906., 62922.,  64632.,  66675.,  68394.,  70464.,  72192.,
      35898., 37068., 38424.,  39600.,  40974.,  42156.,  43548.,  44736.,
      21812., 22664., 23624.,  24480.,  25452.,  26312.,  27296.,  28160.,
      28442., 29756., 31208.,  32528.,  33998.,  35324.,  36812.,  38144.,
      15812., 16712., 17688.,  18592.,  19580.,  20488.,  21488.,  22400.,
      60354., 61932., 63744.,  65328.,  67158.,  68748.,  70596.,  72192.,
      82965., 85386., 88122.,  90552.,  93315.,  95754.,  98544.,  100992.,
      49818., 51468., 53304.,  54960.,  56814.,  58476.,  60348.,  62016.,
      69234., 71052., 73104.,  74928.,  76998.,  78828.,  80916.,  82752.,
      94845., 97626., 100722., 103512., 106635., 109434., 112584., 115392.,
      56778., 58668., 60744.,  62640.,  64734.,  66636.,  68748.,  70656.,
      33812., 35144., 36584.,  37920.,  39372.,  40712.,  42176.,  43520.,
      43562., 45596., 47768.,  49808.,  51998.,  54044.,  56252.,  58304.,
      23972., 25352., 26808.,  28192.,  29660.,  31048.,  32528.,  33920.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10497., 10722., 11262.,  11496.,  12063.,  12306.,  12900.,  13152.,
      12873., 13170., 13782.,  14088.,  14727.,  15042.,  15708.,  16032.,
      22377., 22962., 23862.,  24456.,  25383.,  25986.,  26940.,  27552.,
      24753., 25410., 26382.,  27048.,  28047.,  28722.,  29748.,  30432.,
      46137., 47442., 49062.,  50376.,  52023.,  53346.,  55020.,  56352.,
      48513., 49890., 51582.,  52968.,  54687.,  56082.,  57828.,  59232.,
      58017., 59682., 61662.,  63336.,  65343.,  67026.,  69060.,  70752.,
      60393., 62130., 64182.,  65928.,  68007.,  69762.,  71868.,  73632.,
      81777., 84162., 86862.,  89256.,  91983.,  94386.,  97140.,  99552.,
      84153., 86610., 89382.,  91848.,  94647.,  97122.,  99948.,  102432.,
      93657., 96402., 99462.,  102216., 105303., 108066., 111180., 113952.,
      96033., 98850., 101982., 104808., 107967., 110802., 113988., 116832.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14010.,  14148.,  14286.,  14424.,  15024.,  15168.,  15312.,  15456.,
      16086.,  16236.,  16386.,  16536.,  17196.,  17352.,  17508.,  17664.,
      23109.,  23370.,  23631.,  23892.,  24774.,  25044.,  25314.,  25584.,
      26511.,  26790.,  27069.,  27348.,  28320.,  28608.,  28896.,  29184.,
      15906.,  16116.,  16326.,  16536.,  17112.,  17328.,  17544.,  17760.,
      18366.,  18588.,  18810.,  19032.,  19668.,  19896.,  20124.,  20352.,
      31530.,  31908.,  32286.,  32664.,  33504.,  33888.,  34272.,  34656.,
      35526.,  35916.,  36306.,  36696.,  37596.,  37992.,  38388.,  38784.,
      46509.,  47130.,  47751.,  48372.,  49614.,  50244.,  50874.,  51504.,
      52791.,  53430.,  54069.,  54708.,  56040.,  56688.,  57336.,  57984.,
      29586.,  30036.,  30486.,  30936.,  31752.,  32208.,  32664.,  33120.,
      33966.,  34428.,  34890.,  35352.,  36228.,  36696.,  37164.,  37632.,
      19252.,  19624.,  19996.,  20368.,  20952.,  21328.,  21704.,  22080.,
      22684.,  23064.,  23444.,  23824.,  24448.,  24832.,  25216.,  25600.,
      26050.,  26644.,  27238.,  27832.,  28696.,  29296.,  29896.,  30496.,
      31390.,  31996.,  32602.,  33208.,  34132.,  34744.,  35356.,  35968.,
      14884.,  15304.,  15724.,  16144.,  16712.,  17136.,  17560.,  17984.,
      18572.,  19000.,  19428.,  19856.,  20464.,  20896.,  21328.,  21760.,
      66570.,  67428.,  68286.,  69144.,  70464.,  71328.,  72192.,  73056.,
      74406.,  75276.,  76146.,  77016.,  78396.,  79272.,  80148.,  81024.,
      93309.,  94650.,  95991.,  97332.,  99294.,  100644., 101994., 103344.,
      105351., 106710., 108069., 109428., 111480., 112848., 114216., 115584.,
      56946.,  57876.,  58806.,  59736.,  61032.,  61968.,  62904.,  63840.,
      65166.,  66108.,  67050.,  67992.,  69348.,  70296.,  71244.,  72192.,
      84090.,  85188.,  86286.,  87384.,  88944.,  90048.,  91152.,  92256.,
      93846.,  94956.,  96066.,  97176.,  98796.,  99912.,  101028., 102144.,
      116709., 118410., 120111., 121812., 124134., 125844., 127554., 129264.,
      131631., 133350., 135069., 136788., 139200., 140928., 142656., 144384.,
      70626.,  71796.,  72966.,  74136.,  75672.,  76848.,  78024.,  79200.,
      80766.,  81948.,  83130.,  84312.,  85908.,  87096.,  88284.,  89472.,
      42772.,  43624.,  44476.,  45328.,  46392.,  47248.,  48104.,  48960.,
      50044.,  50904.,  51764.,  52624.,  53728.,  54592.,  55456.,  56320.,
      55570.,  56884.,  58198.,  59512.,  61096.,  62416.,  63736.,  65056.,
      66670.,  67996.,  69322.,  70648.,  72292.,  73624.,  74956.,  76288.,
      30724.,  31624.,  32524.,  33424.,  34472.,  35376.,  36280.,  37184.,
      38252.,  39160.,  40068.,  40976.,  42064.,  42976.,  43888.,  44800.,
      119130., 120708., 122286., 123864., 125904., 127488., 129072., 130656.,
      132726., 134316., 135906., 137496., 139596., 141192., 142788., 144384.,
      163509., 165930., 168351., 170772., 173814., 176244., 178674., 181104.,
      184191., 186630., 189069., 191508., 194640., 197088., 199536., 201984.,
      97986.,  99636.,  101286., 102936., 104952., 106608., 108264., 109920.,
      111966., 113628., 115290., 116952., 119028., 120696., 122364., 124032.,
      136650., 138468., 140286., 142104., 144384., 146208., 148032., 149856.,
      152166., 153996., 155826., 157656., 159996., 161832., 163668., 165504.,
      186909., 189690., 192471., 195252., 198654., 201444., 204234., 207024.,
      210471., 213270., 216069., 218868., 222360., 225168., 227976., 230784.,
      111666., 113556., 115446., 117336., 119592., 121488., 123384., 125280.,
      127566., 129468., 131370., 133272., 135588., 137496., 139404., 141312.,
      66292.,  67624.,  68956.,  70288.,  71832.,  73168.,  74504.,  75840.,
      77404.,  78744.,  80084.,  81424.,  83008.,  84352.,  85696.,  87040.,
      85090.,  87124.,  89158.,  91192.,  93496.,  95536.,  97576.,  99616.,
      101950., 103996., 106042., 108088., 110452., 112504., 114556., 116608.,
      46564.,  47944.,  49324.,  50704.,  52232.,  53616.,  55000.,  56384.,
      57932.,  59320.,  60708.,  62096.,  63664.,  65056.,  66448.,  67840.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20769.,  20994.,  21219.,  21444.,  22290.,  22524.,  22758.,  22992.,
      23883.,  24126.,  24369.,  24612.,  25548.,  25800.,  26052.,  26304.,
      25449.,  25746.,  26043.,  26340.,  27258.,  27564.,  27870.,  28176.,
      29139.,  29454.,  29769.,  30084.,  31092.,  31416.,  31740.,  32064.,
      44169.,  44754.,  45339.,  45924.,  47130.,  47724.,  48318.,  48912.,
      50163.,  50766.,  51369.,  51972.,  53268.,  53880.,  54492.,  55104.,
      48849.,  49506.,  50163.,  50820.,  52098.,  52764.,  53430.,  54096.,
      55419.,  56094.,  56769.,  57444.,  58812.,  59496.,  60180.,  60864.,
      90969.,  92274.,  93579.,  94884.,  96810.,  98124.,  99438.,  100752.,
      102723., 104046., 105369., 106692., 108708., 110040., 111372., 112704.,
      95649.,  97026.,  98403.,  99780.,  101778., 103164., 104550., 105936.,
      107979., 109374., 110769., 112164., 114252., 115656., 117060., 118464.,
      114369., 116034., 117699., 119364., 121650., 123324., 124998., 126672.,
      129003., 130686., 132369., 134052., 136428., 138120., 139812., 141504.,
      119049., 120786., 122523., 124260., 126618., 128364., 130110., 131856.,
      134259., 136014., 137769., 139524., 141972., 143736., 145500., 147264.,
      161169., 163554., 165939., 168324., 171330., 173724., 176118., 178512.,
      181563., 183966., 186369., 188772., 191868., 194280., 196692., 199104.,
      165849., 168306., 170763., 173220., 176298., 178764., 181230., 183696.,
      186819., 189294., 191769., 194244., 197412., 199896., 202380., 204864.,
      184569., 187314., 190059., 192804., 196170., 198924., 201678., 204432.,
      207843., 210606., 213369., 216132., 219588., 222360., 225132., 227904.,
      189249., 192066., 194883., 197700., 201138., 203964., 206790., 209616.,
      213099., 215934., 218769., 221604., 225132., 227976., 230820., 233664.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474.,  564.,  384.,  1014., 1104., 708.,  640.,  682.,  409.,
      2094., 2184., 1356., 2634., 2724., 1680., 1396., 1438., 841.,
      3714., 3804., 2328., 4254., 4344., 2652., 2152., 2194., 1273.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474.,  564.,  1014., 1104.,
                                         2094., 2184., 2634., 2724.,
                                         3714., 3804., 4254., 4344.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038., 1128., 699.,  768.,  1848., 2028., 2010.,
      2208., 1275., 1416., 1106., 1280., 1178., 1364., 688.,  818.,
      3792., 4188., 3954., 4368., 2427., 2712., 4764., 5268., 4926.,
      5448., 3003., 3360., 2402., 2792., 2474., 2876., 1408., 1682.,
      6708., 7428., 6870., 7608., 4155., 4656., 7680., 8508., 7842.,
      8688., 4731., 5304., 3698., 4304., 3770., 4388., 2128., 2546.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038., 1128., 1848., 2028., 2010., 2208.,
      3792., 4188., 3954., 4368., 4764., 5268., 4926., 5448.,
      6708., 7428., 6870., 7608., 7680., 8508., 7842., 8688.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1986.,  2076.,  2166.,  2256.,  1329.,
      1398.,  1467.,  1536.,  3516.,  3696.,  3876.,  4056.,  3822.,  4020.,
      4218.,  4416.,  2409.,  2550.,  2691.,  2832.,  2038.,  2212.,  2386.,
      2560.,  2170.,  2356.,  2542.,  2728.,  1246.,  1376.,  1506.,  1636.,
      7188.,  7584.,  7980.,  8376.,  7494.,  7908.,  8322.,  8736.,  4569.,
      4854.,  5139.,  5424.,  9024.,  9528.,  10032., 10536., 9330.,  9852.,
      10374., 10896., 5649.,  6006.,  6363.,  6720.,  4414.,  4804.,  5194.,
      5584.,  4546.,  4948.,  5350.,  5752.,  2542.,  2816.,  3090.,  3364.,
      12696., 13416., 14136., 14856., 13002., 13740., 14478., 15216., 7809.,
      8310.,  8811.,  9312.,  14532., 15360., 16188., 17016., 14838., 15684.,
      16530., 17376., 8889.,  9462.,  10035., 10608., 6790.,  7396.,  8002.,
      8608.,  6922.,  7540.,  8158.,  8776.,  3838.,  4256.,  4674.,  5092.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1986.,  2076.,  2166.,  2256.,
      3516.,  3696.,  3876.,  4056.,  3822.,  4020.,  4218.,  4416.,
      7188.,  7584.,  7980.,  8376.,  7494.,  7908.,  8322.,  8736.,
      9024.,  9528.,  10032., 10536., 9330.,  9852.,  10374., 10896.,
      12696., 13416., 14136., 14856., 13002., 13740., 14478., 15216.,
      14532., 15360., 16188., 17016., 14838., 15684., 16530., 17376.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1671.,  1896.,  1995.,  2256.,  1350., 1536., 3615.,  4056.,  3939.,
      4416.,  2502.,  2832.,  2176.,  2560., 2320., 2728.,  1356.,  1636.,
      7503.,  8376.,  7827.,  8736.,  4806., 5424., 9447.,  10536., 9771.,
      10896., 5958.,  6720.,  4768.,  5584., 4912., 5752.,  2796.,  3364.,
      13335., 14856., 13659., 15216., 8262., 9312., 15279., 17016., 15603.,
      17376., 9414.,  10608., 7360.,  8608., 7504., 8776.,  4236.,  5092.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1671.,  1896.,  1995.,  2256.,  3615.,  4056.,  3939.,  4416.,
      7503.,  8376.,  7827.,  8736.,  9447.,  10536., 9771.,  10896.,
      13335., 14856., 13659., 15216., 15279., 17016., 15603., 17376.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207.,  3342.,  3648.,  3792.,  3819.,  3990.,  4332.,  4512.,  2568.,
      2700.,  2934.,  3072.,  6879.,  7230.,  7752.,  8112.,  7491.,  7878.,
      8436.,  8832.,  4728.,  5004.,  5382.,  5664.,  4010.,  4352.,  4772.,
      5120.,  4274.,  4640.,  5084.,  5456.,  2456.,  2712.,  3012.,  3272.,
      14223., 15006., 15960., 16752., 14835., 15654., 16644., 17472., 9048.,
      9612.,  10278., 10848., 17895., 18894., 20064., 21072., 18507., 19542.,
      20748., 21792., 11208., 11916., 12726., 13440., 8762.,  9536.,  10388.,
      11168., 9026.,  9824.,  10700., 11504., 5048.,  5592.,  6180.,  6728.,
      25239., 26670., 28272., 29712., 25851., 27318., 28956., 30432., 15528.,
      16524., 17622., 18624., 28911., 30558., 32376., 34032., 29523., 31206.,
      33060., 34752., 17688., 18828., 20070., 21216., 13514., 14720., 16004.,
      17216., 13778., 15008., 16316., 17552., 7640.,  8472.,  9348.,  10184.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207.,  3342.,  3648.,  3792.,  3819.,  3990.,  4332.,  4512.,
      6879.,  7230.,  7752.,  8112.,  7491.,  7878.,  8436.,  8832.,
      14223., 15006., 15960., 16752., 14835., 15654., 16644., 17472.,
      17895., 18894., 20064., 21072., 18507., 19542., 20748., 21792.,
      25239., 26670., 28272., 29712., 25851., 27318., 28956., 30432.,
      28911., 30558., 32376., 34032., 29523., 31206., 33060., 34752.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6279.,  6414.,  6549.,  6684.,  7152.,  7296.,  7440.,  7584.,  7467.,
      7638.,  7809.,  7980.,  8484.,  8664.,  8844.,  9024.,  5004.,  5136.,
      5268.,  5400.,  5730.,  5868.,  6006.,  6144.,  13407., 13758., 14109.,
      14460., 15144., 15504., 15864., 16224., 14595., 14982., 15369., 15756.,
      16476., 16872., 17268., 17664., 9180.,  9456.,  9732.,  10008., 10482.,
      10764., 11046., 11328., 7678.,  8020.,  8362.,  8704.,  9196.,  9544.,
      9892.,  10240., 8182.,  8548.,  8914.,  9280.,  9796.,  10168., 10540.,
      10912., 4656.,  4912.,  5168.,  5424.,  5764.,  6024.,  6284.,  6544.,
      27663., 28446., 29229., 30012., 31128., 31920., 32712., 33504., 28851.,
      29670., 30489., 31308., 32460., 33288., 34116., 34944., 17532., 18096.,
      18660., 19224., 19986., 20556., 21126., 21696., 34791., 35790., 36789.,
      37788., 39120., 40128., 41136., 42144., 35979., 37014., 38049., 39084.,
      40452., 41496., 42540., 43584., 21708., 22416., 23124., 23832., 24738.,
      25452., 26166., 26880., 16750., 17524., 18298., 19072., 19996., 20776.,
      21556., 22336., 17254., 18052., 18850., 19648., 20596., 21400., 22204.,
      23008., 9552.,  10096., 10640., 11184., 11812., 12360., 12908., 13456.,
      49047., 50478., 51909., 53340., 55104., 56544., 57984., 59424., 50235.,
      51702., 53169., 54636., 56436., 57912., 59388., 60864., 30060., 31056.,
      32052., 33048., 34242., 35244., 36246., 37248., 56175., 57822., 59469.,
      61116., 63096., 64752., 66408., 68064., 57363., 59046., 60729., 62412.,
      64428., 66120., 67812., 69504., 34236., 35376., 36516., 37656., 38994.,
      40140., 41286., 42432., 25822., 27028., 28234., 29440., 30796., 32008.,
      33220., 34432., 26326., 27556., 28786., 30016., 31396., 32632., 33868.,
      35104., 14448., 15280., 16112., 16944., 17860., 18696., 19532., 20368.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6279.,  6414.,  6549.,  6684.,  7152.,  7296.,  7440.,  7584.,  7467.,
      7638.,  7809.,  7980.,  8484.,  8664.,  8844.,  9024.,  13407., 13758.,
      14109., 14460., 15144., 15504., 15864., 16224., 14595., 14982., 15369.,
      15756., 16476., 16872., 17268., 17664., 27663., 28446., 29229., 30012.,
      31128., 31920., 32712., 33504., 28851., 29670., 30489., 31308., 32460.,
      33288., 34116., 34944., 34791., 35790., 36789., 37788., 39120., 40128.,
      41136., 42144., 35979., 37014., 38049., 39084., 40452., 41496., 42540.,
      43584., 49047., 50478., 51909., 53340., 55104., 56544., 57984., 59424.,
      50235., 51702., 53169., 54636., 56436., 57912., 59388., 60864., 56175.,
      57822., 59469., 61116., 63096., 64752., 66408., 68064., 57363., 59046.,
      60729., 62412., 64428., 66120., 67812., 69504.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261.,  6684.,  7125.,  7584.,  7485.,  7980.,  8493.,  9024.,  5046.,
      5400.,  5766.,  6144.,  13605., 14460., 15333., 16224., 14829., 15756.,
      16701., 17664., 9366.,  10008., 10662., 11328., 7954.,  8704.,  9466.,
      10240., 8482.,  9280.,  10090., 10912., 4876.,  5424.,  5980.,  6544.,
      28293., 30012., 31749., 33504., 29517., 31308., 33117., 34944., 18006.,
      19224., 20454., 21696., 35637., 37788., 39957., 42144., 36861., 39084.,
      41325., 43584., 22326., 23832., 25350., 26880., 17458., 19072., 20698.,
      22336., 17986., 19648., 21322., 23008., 10060., 11184., 12316., 13456.,
      50325., 53340., 56373., 59424., 51549., 54636., 57741., 60864., 30966.,
      33048., 35142., 37248., 57669., 61116., 64581., 68064., 58893., 62412.,
      65949., 69504., 35286., 37656., 40038., 42432., 26962., 29440., 31930.,
      34432., 27490., 30016., 32554., 35104., 15244., 16944., 18652., 20368.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261.,  6684.,  7125.,  7584.,  7485.,  7980.,  8493.,  9024.,
      13605., 14460., 15333., 16224., 14829., 15756., 16701., 17664.,
      28293., 30012., 31749., 33504., 29517., 31308., 33117., 34944.,
      35637., 37788., 39957., 42144., 36861., 39084., 41325., 43584.,
      50325., 53340., 56373., 59424., 51549., 54636., 57741., 60864.,
      57669., 61116., 64581., 68064., 58893., 62412., 65949., 69504.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261.,  12522.,  13098.,  13368.,  13971.,  14250.,  14880.,  15168.,
      14637.,  14970.,  15618.,  15960.,  16635.,  16986.,  17688.,  18048.,
      9834.,   10092.,  10536.,  10800.,  11262.,  11532.,  12012.,  12288.,
      26517.,  27210.,  28218.,  28920.,  29955.,  30666.,  31728.,  32448.,
      28893.,  29658.,  30738.,  31512.,  32619.,  33402.,  34536.,  35328.,
      18186.,  18732.,  19464.,  20016.,  20766.,  21324.,  22092.,  22656.,
      15230.,  15908.,  16724.,  17408.,  18242.,  18932.,  19784.,  20480.,
      16238.,  16964.,  17828.,  18560.,  19442.,  20180.,  21080.,  21824.,
      9244.,   9752.,   10336.,  10848.,  11444.,  11960.,  12568.,  13088.,
      55029.,  56586.,  58458.,  60024.,  61923.,  63498.,  65424.,  67008.,
      57405.,  59034.,  60978.,  62616.,  64587.,  66234.,  68232.,  69888.,
      34890.,  36012.,  37320.,  38448.,  39774.,  40908.,  42252.,  43392.,
      69285.,  71274.,  73578.,  75576.,  77907.,  79914.,  82272.,  84288.,
      71661.,  73722.,  76098.,  78168.,  80571.,  82650.,  85080.,  87168.,
      43242.,  44652.,  46248.,  47664.,  49278.,  50700.,  52332.,  53760.,
      33374.,  34916.,  36596.,  38144.,  39842.,  41396.,  43112.,  44672.,
      34382.,  35972.,  37700.,  39296.,  41042.,  42644.,  44408.,  46016.,
      19036.,  20120.,  21280.,  22368.,  23540.,  24632.,  25816.,  26912.,
      97797.,  100650., 103818., 106680., 109875., 112746., 115968., 118848.,
      100173., 103098., 106338., 109272., 112539., 115482., 118776., 121728.,
      59946.,  61932.,  64104.,  66096.,  68286.,  70284.,  72492.,  74496.,
      112053., 115338., 118938., 122232., 125859., 129162., 132816., 136128.,
      114429., 117786., 121458., 124824., 128523., 131898., 135624., 139008.,
      68298.,  70572.,  73032.,  75312.,  77790.,  80076.,  82572.,  84864.,
      51518.,  53924.,  56468.,  58880.,  61442.,  63860.,  66440.,  68864.,
      52526.,  54980.,  57572.,  60032.,  62642.,  65108.,  67736.,  70208.,
      28828.,  30488.,  32224.,  33888.,  35636.,  37304.,  39064.,  40736.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261.,  12522.,  13098.,  13368.,  13971.,  14250.,  14880.,  15168.,
      14637.,  14970.,  15618.,  15960.,  16635.,  16986.,  17688.,  18048.,
      26517.,  27210.,  28218.,  28920.,  29955.,  30666.,  31728.,  32448.,
      28893.,  29658.,  30738.,  31512.,  32619.,  33402.,  34536.,  35328.,
      55029.,  56586.,  58458.,  60024.,  61923.,  63498.,  65424.,  67008.,
      57405.,  59034.,  60978.,  62616.,  64587.,  66234.,  68232.,  69888.,
      69285.,  71274.,  73578.,  75576.,  77907.,  79914.,  82272.,  84288.,
      71661.,  73722.,  76098.,  78168.,  80571.,  82650.,  85080.,  87168.,
      97797.,  100650., 103818., 106680., 109875., 112746., 115968., 118848.,
      100173., 103098., 106338., 109272., 112539., 115482., 118776., 121728.,
      112053., 115338., 118938., 122232., 125859., 129162., 132816., 136128.,
      114429., 117786., 121458., 124824., 128523., 131898., 135624., 139008.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24261.,  24522.,  24783.,  25044.,  25926.,  26196.,  26466.,  26736.,
      27663.,  27942.,  28221.,  28500.,  29472.,  29760.,  30048.,  30336.,
      28941.,  29274.,  29607.,  29940.,  30894.,  31236.,  31578.,  31920.,
      32919.,  33270.,  33621.,  33972.,  35016.,  35376.,  35736.,  36096.,
      19410.,  19668.,  19926.,  20184.,  20808.,  21072.,  21336.,  21600.,
      22254.,  22524.,  22794.,  23064.,  23748.,  24024.,  24300.,  24576.,
      52341.,  53034.,  53727.,  54420.,  55734.,  56436.,  57138.,  57840.,
      59199.,  59910.,  60621.,  61332.,  62736.,  63456.,  64176.,  64896.,
      57021.,  57786.,  58551.,  59316.,  60702.,  61476.,  62250.,  63024.,
      64455.,  65238.,  66021.,  66804.,  68280.,  69072.,  69864.,  70656.,
      35826.,  36372.,  36918.,  37464.,  38376.,  38928.,  39480.,  40032.,
      40974.,  41532.,  42090.,  42648.,  43620.,  44184.,  44748.,  45312.,
      29782.,  30460.,  31138.,  31816.,  32764.,  33448.,  34132.,  34816.,
      35794.,  36484.,  37174.,  37864.,  38872.,  39568.,  40264.,  40960.,
      31750.,  32476.,  33202.,  33928.,  34924.,  35656.,  36388.,  37120.,
      38146.,  38884.,  39622.,  40360.,  41416.,  42160.,  42904.,  43648.,
      17980.,  18488.,  18996.,  19504.,  20160.,  20672.,  21184.,  21696.,
      22372.,  22888.,  23404.,  23920.,  24616.,  25136.,  25656.,  26176.,
      108501., 110058., 111615., 113172., 115350., 116916., 118482., 120048.,
      122271., 123846., 125421., 126996., 129264., 130848., 132432., 134016.,
      113181., 114810., 116439., 118068., 120318., 121956., 123594., 125232.,
      127527., 129174., 130821., 132468., 134808., 136464., 138120., 139776.,
      68658.,  69780.,  70902.,  72024.,  73512.,  74640.,  75768.,  76896.,
      78414.,  79548.,  80682.,  81816.,  83364.,  84504.,  85644.,  86784.,
      136581., 138570., 140559., 142548., 145158., 147156., 149154., 151152.,
      153807., 155814., 157821., 159828., 162528., 164544., 166560., 168576.,
      141261., 143322., 145383., 147444., 150126., 152196., 154266., 156336.,
      159063., 161142., 163221., 165300., 168072., 170160., 172248., 174336.,
      85074.,  86484.,  87894.,  89304.,  91080.,  92496.,  93912.,  95328.,
      97134.,  98556.,  99978.,  101400., 103236., 104664., 106092., 107520.,
      65206.,  66748.,  68290.,  69832.,  71644.,  73192.,  74740.,  76288.,
      78130.,  79684.,  81238.,  82792.,  84664.,  86224.,  87784.,  89344.,
      67174.,  68764.,  70354.,  71944.,  73804.,  75400.,  76996.,  78592.,
      80482.,  82084.,  83686.,  85288.,  87208.,  88816.,  90424.,  92032.,
      36988.,  38072.,  39156.,  40240.,  41472.,  42560.,  43648.,  44736.,
      45988.,  47080.,  48172.,  49264.,  50536.,  51632.,  52728.,  53824.,
      192741., 195594., 198447., 201300., 204774., 207636., 210498., 213360.,
      216879., 219750., 222621., 225492., 229056., 231936., 234816., 237696.,
      197421., 200346., 203271., 206196., 209742., 212676., 215610., 218544.,
      222135., 225078., 228021., 230964., 234600., 237552., 240504., 243456.,
      117906., 119892., 121878., 123864., 126216., 128208., 130200., 132192.,
      134574., 136572., 138570., 140568., 142980., 144984., 146988., 148992.,
      220821., 224106., 227391., 230676., 234582., 237876., 241170., 244464.,
      248415., 251718., 255021., 258324., 262320., 265632., 268944., 272256.,
      225501., 228858., 232215., 235572., 239550., 242916., 246282., 249648.,
      253671., 257046., 260421., 263796., 267864., 271248., 274632., 278016.,
      134322., 136596., 138870., 141144., 143784., 146064., 148344., 150624.,
      153294., 155580., 157866., 160152., 162852., 165144., 167436., 169728.,
      100630., 103036., 105442., 107848., 110524., 112936., 115348., 117760.,
      120466., 122884., 125302., 127720., 130456., 132880., 135304., 137728.,
      102598., 105052., 107506., 109960., 112684., 115144., 117604., 120064.,
      122818., 125284., 127750., 130216., 133000., 135472., 137944., 140416.,
      55996.,  57656.,  59316.,  60976.,  62784.,  64448.,  66112.,  67776.,
      69604.,  71272.,  72940.,  74608.,  76456.,  78128.,  79800.,  81472.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24261.,  24522.,  24783.,  25044.,  25926.,  26196.,  26466.,  26736.,
      27663.,  27942.,  28221.,  28500.,  29472.,  29760.,  30048.,  30336.,
      28941.,  29274.,  29607.,  29940.,  30894.,  31236.,  31578.,  31920.,
      32919.,  33270.,  33621.,  33972.,  35016.,  35376.,  35736.,  36096.,
      52341.,  53034.,  53727.,  54420.,  55734.,  56436.,  57138.,  57840.,
      59199.,  59910.,  60621.,  61332.,  62736.,  63456.,  64176.,  64896.,
      57021.,  57786.,  58551.,  59316.,  60702.,  61476.,  62250.,  63024.,
      64455.,  65238.,  66021.,  66804.,  68280.,  69072.,  69864.,  70656.,
      108501., 110058., 111615., 113172., 115350., 116916., 118482., 120048.,
      122271., 123846., 125421., 126996., 129264., 130848., 132432., 134016.,
      113181., 114810., 116439., 118068., 120318., 121956., 123594., 125232.,
      127527., 129174., 130821., 132468., 134808., 136464., 138120., 139776.,
      136581., 138570., 140559., 142548., 145158., 147156., 149154., 151152.,
      153807., 155814., 157821., 159828., 162528., 164544., 166560., 168576.,
      141261., 143322., 145383., 147444., 150126., 152196., 154266., 156336.,
      159063., 161142., 163221., 165300., 168072., 170160., 172248., 174336.,
      192741., 195594., 198447., 201300., 204774., 207636., 210498., 213360.,
      216879., 219750., 222621., 225492., 229056., 231936., 234816., 237696.,
      197421., 200346., 203271., 206196., 209742., 212676., 215610., 218544.,
      222135., 225078., 228021., 230964., 234600., 237552., 240504., 243456.,
      220821., 224106., 227391., 230676., 234582., 237876., 241170., 244464.,
      248415., 251718., 255021., 258324., 262320., 265632., 268944., 272256.,
      225501., 228858., 232215., 235572., 239550., 242916., 246282., 249648.,
      253671., 257046., 260421., 263796., 267864., 271248., 274632., 278016.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  516.,  1320., 1410., 1500., 948.,  838.,
      880.,  922.,  547.,  2760., 2850., 2940., 1812., 3480., 3570.,
      3660., 2244., 1846., 1888., 1930., 1123., 4920., 5010., 5100.,
      3108., 5640., 5730., 5820., 3540., 2854., 2896., 2938., 1699.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  1320., 1410., 1500., 2760., 2850., 2940.,
      3480., 3570., 3660., 4920., 5010., 5100., 5640., 5730., 5820.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110., 1200., 1272.,  1380.,  1434.,  1560.,  939.,   1032.,  2406.,
      2640., 2568., 2820.,  2730.,  3000.,  1707.,  1896.,  1448.,  1676.,
      1520., 1760., 1592.,  1844.,  920.,   1094.,  4998.,  5520.,  5160.,
      5700., 5322., 5880.,  3243.,  3624.,  6294.,  6960.,  6456.,  7140.,
      6618., 7320., 4011.,  4488.,  3176.,  3692.,  3248.,  3776.,  3320.,
      3860., 1880., 2246.,  8886.,  9840.,  9048.,  10020., 9210.,  10200.,
      5547., 6216., 10182., 11280., 10344., 11460., 10506., 11640., 6315.,
      7080., 4904., 5708.,  4976.,  5792.,  5048.,  5876.,  2840.,  3398.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110.,  1200., 1272.,  1380.,  1434.,  1560.,  2406.,  2640.,  2568.,
      2820.,  2730., 3000.,  4998.,  5520.,  5160.,  5700.,  5322.,  5880.,
      6294.,  6960., 6456.,  7140.,  6618.,  7320.,  8886.,  9840.,  9048.,
      10020., 9210., 10200., 10182., 11280., 10344., 11460., 10506., 11640.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130.,  2220.,  2310.,  2400.,  2436.,  2544.,  2652.,  2760.,  2742.,
      2868.,  2994.,  3120.,  1785.,  1878.,  1971.,  2064.,  4578.,  4812.,
      5046.,  5280.,  4884.,  5136.,  5388.,  5640.,  5190.,  5460.,  5730.,
      6000.,  3225.,  3414.,  3603.,  3792.,  2668.,  2896.,  3124.,  3352.,
      2800.,  3040.,  3280.,  3520.,  2932.,  3184.,  3436.,  3688.,  1666.,
      1840.,  2014.,  2188.,  9474.,  9996.,  10518., 11040., 9780.,  10320.,
      10860., 11400., 10086., 10644., 11202., 11760., 6105.,  6486.,  6867.,
      7248.,  11922., 12588., 13254., 13920., 12228., 12912., 13596., 14280.,
      12534., 13236., 13938., 14640., 7545.,  8022.,  8499.,  8976.,  5836.,
      6352.,  6868.,  7384.,  5968.,  6496.,  7024.,  7552.,  6100.,  6640.,
      7180.,  7720.,  3394.,  3760.,  4126.,  4492.,  16818., 17772., 18726.,
      19680., 17124., 18096., 19068., 20040., 17430., 18420., 19410., 20400.,
      10425., 11094., 11763., 12432., 19266., 20364., 21462., 22560., 19572.,
      20688., 21804., 22920., 19878., 21012., 22146., 23280., 11865., 12630.,
      13395., 14160., 9004.,  9808.,  10612., 11416., 9136.,  9952.,  10768.,
      11584., 9268.,  10096., 10924., 11752., 5122.,  5680.,  6238.,  6796.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130.,  2220.,  2310.,  2400.,  2436.,  2544.,  2652.,  2760.,  2742.,
      2868.,  2994.,  3120.,  4578.,  4812.,  5046.,  5280.,  4884.,  5136.,
      5388.,  5640.,  5190.,  5460.,  5730.,  6000.,  9474.,  9996.,  10518.,
      11040., 9780.,  10320., 10860., 11400., 10086., 10644., 11202., 11760.,
      11922., 12588., 13254., 13920., 12228., 12912., 13596., 14280., 12534.,
      13236., 13938., 14640., 16818., 17772., 18726., 19680., 17124., 18096.,
      19068., 20040., 17430., 18420., 19410., 20400., 19266., 20364., 21462.,
      22560., 19572., 20688., 21804., 22920., 19878., 21012., 22146., 23280.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2139.,  2400.,  2463.,  2760.,  2787.,  3120.,  1830.,  2064.,  4731.,
      5280.,  5055.,  5640.,  5379.,  6000.,  3366.,  3792.,  2860.,  3352.,
      3004.,  3520.,  3148.,  3688.,  1820.,  2188.,  9915.,  11040., 10239.,
      11400., 10563., 11760., 6438.,  7248.,  12507., 13920., 12831., 14280.,
      13155., 14640., 7974.,  8976.,  6316.,  7384.,  6460.,  7552.,  6604.,
      7720.,  3740.,  4492.,  17691., 19680., 18015., 20040., 18339., 20400.,
      11046., 12432., 20283., 22560., 20607., 22920., 20931., 23280., 12582.,
      14160., 9772.,  11416., 9916.,  11584., 10060., 11752., 5660.,  6796.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2139.,  2400.,  2463.,  2760.,  2787.,  3120.,  4731.,  5280.,  5055.,
      5640.,  5379.,  6000.,  9915.,  11040., 10239., 11400., 10563., 11760.,
      12507., 13920., 12831., 14280., 13155., 14640., 17691., 19680., 18015.,
      20040., 18339., 20400., 20283., 22560., 20607., 22920., 20931., 23280.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107.,  4278.,  4620.,  4800.,  4719.,  4926.,  5304.,  5520.,  5331.,
      5574.,  5988.,  6240.,  3480.,  3660.,  3942.,  4128.,  9003.,  9462.,
      10092., 10560., 9615.,  10110., 10776., 11280., 10227., 10758., 11460.,
      12000., 6360.,  6732.,  7206.,  7584.,  5270.,  5720.,  6248.,  6704.,
      5534.,  6008.,  6560.,  7040.,  5798.,  6296.,  6872.,  7376.,  3296.,
      3640.,  4028.,  4376.,  18795., 19830., 21036., 22080., 19407., 20478.,
      21720., 22800., 20019., 21126., 22404., 23520., 12120., 12876., 13734.,
      14496., 23691., 25014., 26508., 27840., 24303., 25662., 27192., 28560.,
      24915., 26310., 27876., 29280., 15000., 15948., 16998., 17952., 11606.,
      12632., 13736., 14768., 11870., 12920., 14048., 15104., 12134., 13208.,
      14360., 15440., 6752.,  7480.,  8252.,  8984.,  33483., 35382., 37452.,
      39360., 34095., 36030., 38136., 40080., 34707., 36678., 38820., 40800.,
      20760., 22092., 23526., 24864., 38379., 40566., 42924., 45120., 38991.,
      41214., 43608., 45840., 39603., 41862., 44292., 46560., 23640., 25164.,
      26790., 28320., 17942., 19544., 21224., 22832., 18206., 19832., 21536.,
      23168., 18470., 20120., 21848., 23504., 10208., 11320., 12476., 13592.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107.,  4278.,  4620.,  4800.,  4719.,  4926.,  5304.,  5520.,  5331.,
      5574.,  5988.,  6240.,  9003.,  9462.,  10092., 10560., 9615.,  10110.,
      10776., 11280., 10227., 10758., 11460., 12000., 18795., 19830., 21036.,
      22080., 19407., 20478., 21720., 22800., 20019., 21126., 22404., 23520.,
      23691., 25014., 26508., 27840., 24303., 25662., 27192., 28560., 24915.,
      26310., 27876., 29280., 33483., 35382., 37452., 39360., 34095., 36030.,
      38136., 40080., 34707., 36678., 38820., 40800., 38379., 40566., 42924.,
      45120., 38991., 41214., 43608., 45840., 39603., 41862., 44292., 46560.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8043.,  8214.,  8385.,  8556.,  9060.,  9240.,  9420.,  9600.,  9231.,
      9438.,  9645.,  9852.,  10392., 10608., 10824., 11040., 10419., 10662.,
      10905., 11148., 11724., 11976., 12228., 12480., 6780.,  6960.,  7140.,
      7320.,  7698.,  7884.,  8070.,  8256.,  17547., 18006., 18465., 18924.,
      19716., 20184., 20652., 21120., 18735., 19230., 19725., 20220., 21048.,
      21552., 22056., 22560., 19923., 20454., 20985., 21516., 22380., 22920.,
      23460., 24000., 12348., 12720., 13092., 13464., 14034., 14412., 14790.,
      15168., 10090., 10540., 10990., 11440., 12040., 12496., 12952., 13408.,
      10594., 11068., 11542., 12016., 12640., 13120., 13600., 14080., 11098.,
      11596., 12094., 12592., 13240., 13744., 14248., 14752., 6248.,  6592.,
      6936.,  7280.,  7708.,  8056.,  8404.,  8752.,  36555., 37590., 38625.,
      39660., 41028., 42072., 43116., 44160., 37743., 38814., 39885., 40956.,
      42360., 43440., 44520., 45600., 38931., 40038., 41145., 42252., 43692.,
      44808., 45924., 47040., 23484., 24240., 24996., 25752., 26706., 27468.,
      28230., 28992., 46059., 47382., 48705., 50028., 51684., 53016., 54348.,
      55680., 47247., 48606., 49965., 51324., 53016., 54384., 55752., 57120.,
      48435., 49830., 51225., 52620., 54348., 55752., 57156., 58560., 29052.,
      30000., 30948., 31896., 33042., 33996., 34950., 35904., 22186., 23212.,
      24238., 25264., 26440., 27472., 28504., 29536., 22690., 23740., 24790.,
      25840., 27040., 28096., 29152., 30208., 23194., 24268., 25342., 26416.,
      27640., 28720., 29800., 30880., 12776., 13504., 14232., 14960., 15772.,
      16504., 17236., 17968., 65067., 66966., 68865., 70764., 72996., 74904.,
      76812., 78720., 66255., 68190., 70125., 72060., 74328., 76272., 78216.,
      80160., 67443., 69414., 71385., 73356., 75660., 77640., 79620., 81600.,
      40188., 41520., 42852., 44184., 45714., 47052., 48390., 49728., 74571.,
      76758., 78945., 81132., 83652., 85848., 88044., 90240., 75759., 77982.,
      80205., 82428., 84984., 87216., 89448., 91680., 76947., 79206., 81465.,
      83724., 86316., 88584., 90852., 93120., 45756., 47280., 48804., 50328.,
      52050., 53580., 55110., 56640., 34282., 35884., 37486., 39088., 40840.,
      42448., 44056., 45664., 34786., 36412., 38038., 39664., 41440., 43072.,
      44704., 46336., 35290., 36940., 38590., 40240., 42040., 43696., 45352.,
      47008., 19304., 20416., 21528., 22640., 23836., 24952., 26068., 27184.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8043.,  8214.,  8385.,  8556.,  9060.,  9240.,  9420.,  9600.,  9231.,
      9438.,  9645.,  9852.,  10392., 10608., 10824., 11040., 10419., 10662.,
      10905., 11148., 11724., 11976., 12228., 12480., 17547., 18006., 18465.,
      18924., 19716., 20184., 20652., 21120., 18735., 19230., 19725., 20220.,
      21048., 21552., 22056., 22560., 19923., 20454., 20985., 21516., 22380.,
      22920., 23460., 24000., 36555., 37590., 38625., 39660., 41028., 42072.,
      43116., 44160., 37743., 38814., 39885., 40956., 42360., 43440., 44520.,
      45600., 38931., 40038., 41145., 42252., 43692., 44808., 45924., 47040.,
      46059., 47382., 48705., 50028., 51684., 53016., 54348., 55680., 47247.,
      48606., 49965., 51324., 53016., 54384., 55752., 57120., 48435., 49830.,
      51225., 52620., 54348., 55752., 57156., 58560., 65067., 66966., 68865.,
      70764., 72996., 74904., 76812., 78720., 66255., 68190., 70125., 72060.,
      74328., 76272., 78216., 80160., 67443., 69414., 71385., 73356., 75660.,
      77640., 79620., 81600., 74571., 76758., 78945., 81132., 83652., 85848.,
      88044., 90240., 75759., 77982., 80205., 82428., 84984., 87216., 89448.,
      91680., 76947., 79206., 81465., 83724., 86316., 88584., 90852., 93120.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,  8556.,  9069.,  9600.,  9285.,  9852.,  10437., 11040., 10509.,
      11148., 11805., 12480., 6870.,  7320.,  7782.,  8256.,  17853., 18924.,
      20013., 21120., 19077., 20220., 21381., 22560., 20301., 21516., 22749.,
      24000., 12630., 13464., 14310., 15168., 10474., 11440., 12418., 13408.,
      11002., 12016., 13042., 14080., 11530., 12592., 13666., 14752., 6556.,
      7280.,  8012.,  8752.,  37437., 39660., 41901., 44160., 38661., 40956.,
      43269., 45600., 39885., 42252., 44637., 47040., 24150., 25752., 27366.,
      28992., 47229., 50028., 52845., 55680., 48453., 51324., 54213., 57120.,
      49677., 52620., 55581., 58560., 29910., 31896., 33894., 35904., 23146.,
      25264., 27394., 29536., 23674., 25840., 28018., 30208., 24202., 26416.,
      28642., 30880., 13468., 14960., 16460., 17968., 66813., 70764., 74733.,
      78720., 68037., 72060., 76101., 80160., 69261., 73356., 77469., 81600.,
      41430., 44184., 46950., 49728., 76605., 81132., 85677., 90240., 77829.,
      82428., 87045., 91680., 79053., 83724., 88413., 93120., 47190., 50328.,
      53478., 56640., 35818., 39088., 42370., 45664., 36346., 39664., 42994.,
      46336., 36874., 40240., 43618., 47008., 20380., 22640., 24908., 27184.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,  8556.,  9069.,  9600.,  9285.,  9852.,  10437., 11040., 10509.,
      11148., 11805., 12480., 17853., 18924., 20013., 21120., 19077., 20220.,
      21381., 22560., 20301., 21516., 22749., 24000., 37437., 39660., 41901.,
      44160., 38661., 40956., 43269., 45600., 39885., 42252., 44637., 47040.,
      47229., 50028., 52845., 55680., 48453., 51324., 54213., 57120., 49677.,
      52620., 55581., 58560., 66813., 70764., 74733., 78720., 68037., 72060.,
      76101., 80160., 69261., 73356., 77469., 81600., 76605., 81132., 85677.,
      90240., 77829., 82428., 87045., 91680., 79053., 83724., 88413., 93120.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789.,  16122.,  16770.,  17112.,  17787.,  18138.,  18840.,  19200.,
      18165.,  18570.,  19290.,  19704.,  20451.,  20874.,  21648.,  22080.,
      20541.,  21018.,  21810.,  22296.,  23115.,  23610.,  24456.,  24960.,
      13386.,  13740.,  14280.,  14640.,  15198.,  15564.,  16140.,  16512.,
      34797.,  35706.,  36930.,  37848.,  39099.,  40026.,  41304.,  42240.,
      37173.,  38154.,  39450.,  40440.,  41763.,  42762.,  44112.,  45120.,
      39549.,  40602.,  41970.,  43032.,  44427.,  45498.,  46920.,  48000.,
      24522.,  25260.,  26184.,  26928.,  27870.,  28620.,  29580.,  30336.,
      20054.,  20948.,  21980.,  22880.,  23930.,  24836.,  25904.,  26816.,
      21062.,  22004.,  23084.,  24032.,  25130.,  26084.,  27200.,  28160.,
      22070.,  23060.,  24188.,  25184.,  26330.,  27332.,  28496.,  29504.,
      12428.,  13112.,  13872.,  14560.,  15332.,  16024.,  16808.,  17504.,
      72813.,  74874.,  77250.,  79320.,  81723.,  83802.,  86232.,  88320.,
      75189.,  77322.,  79770.,  81912.,  84387.,  86538.,  89040.,  91200.,
      77565.,  79770.,  82290.,  84504.,  87051.,  89274.,  91848.,  94080.,
      46794.,  48300.,  49992.,  51504.,  53214.,  54732.,  56460.,  57984.,
      91821.,  94458.,  97410.,  100056., 103035., 105690., 108696., 111360.,
      94197.,  96906.,  99930.,  102648., 105699., 108426., 111504., 114240.,
      96573.,  99354.,  102450., 105240., 108363., 111162., 114312., 117120.,
      57930.,  59820.,  61896.,  63792.,  65886.,  67788.,  69900.,  71808.,
      44246.,  46292.,  48476.,  50528.,  52730.,  54788.,  57008.,  59072.,
      45254.,  47348.,  49580.,  51680.,  53930.,  56036.,  58304.,  60416.,
      46262.,  48404.,  50684.,  52832.,  55130.,  57284.,  59600.,  61760.,
      25484.,  26936.,  28464.,  29920.,  31460.,  32920.,  34472.,  35936.,
      129837., 133626., 137730., 141528., 145659., 149466., 153624., 157440.,
      132213., 136074., 140250., 144120., 148323., 152202., 156432., 160320.,
      134589., 138522., 142770., 146712., 150987., 154938., 159240., 163200.,
      80202.,  82860.,  85704.,  88368.,  91230.,  93900.,  96780.,  99456.,
      148845., 153210., 157890., 162264., 166971., 171354., 176088., 180480.,
      151221., 155658., 160410., 164856., 169635., 174090., 178896., 183360.,
      153597., 158106., 162930., 167448., 172299., 176826., 181704., 186240.,
      91338.,  94380.,  97608.,  100656., 103902., 106956., 110220., 113280.,
      68438.,  71636.,  74972.,  78176.,  81530.,  84740.,  88112.,  91328.,
      69446.,  72692.,  76076.,  79328.,  82730.,  85988.,  89408.,  92672.,
      70454.,  73748.,  77180.,  80480.,  83930.,  87236.,  90704.,  94016.,
      38540.,  40760.,  43056.,  45280.,  47588.,  49816.,  52136.,  54368.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789.,  16122.,  16770.,  17112.,  17787.,  18138.,  18840.,  19200.,
      18165.,  18570.,  19290.,  19704.,  20451.,  20874.,  21648.,  22080.,
      20541.,  21018.,  21810.,  22296.,  23115.,  23610.,  24456.,  24960.,
      34797.,  35706.,  36930.,  37848.,  39099.,  40026.,  41304.,  42240.,
      37173.,  38154.,  39450.,  40440.,  41763.,  42762.,  44112.,  45120.,
      39549.,  40602.,  41970.,  43032.,  44427.,  45498.,  46920.,  48000.,
      72813.,  74874.,  77250.,  79320.,  81723.,  83802.,  86232.,  88320.,
      75189.,  77322.,  79770.,  81912.,  84387.,  86538.,  89040.,  91200.,
      77565.,  79770.,  82290.,  84504.,  87051.,  89274.,  91848.,  94080.,
      91821.,  94458.,  97410.,  100056., 103035., 105690., 108696., 111360.,
      94197.,  96906.,  99930.,  102648., 105699., 108426., 111504., 114240.,
      96573.,  99354.,  102450., 105240., 108363., 111162., 114312., 117120.,
      129837., 133626., 137730., 141528., 145659., 149466., 153624., 157440.,
      132213., 136074., 140250., 144120., 148323., 152202., 156432., 160320.,
      134589., 138522., 142770., 146712., 150987., 154938., 159240., 163200.,
      148845., 153210., 157890., 162264., 166971., 171354., 176088., 180480.,
      151221., 155658., 160410., 164856., 169635., 174090., 178896., 183360.,
      153597., 158106., 162930., 167448., 172299., 176826., 181704., 186240.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31245.,  31578.,  31911.,  32244.,  33198.,  33540.,  33882.,  34224.,
      35223.,  35574.,  35925.,  36276.,  37320.,  37680.,  38040.,  38400.,
      35925.,  36330.,  36735.,  37140.,  38166.,  38580.,  38994.,  39408.,
      40479.,  40902.,  41325.,  41748.,  42864.,  43296.,  43728.,  44160.,
      40605.,  41082.,  41559.,  42036.,  43134.,  43620.,  44106.,  44592.,
      45735.,  46230.,  46725.,  47220.,  48408.,  48912.,  49416.,  49920.,
      26418.,  26772.,  27126.,  27480.,  28200.,  28560.,  28920.,  29280.,
      30030.,  30396.,  30762.,  31128.,  31908.,  32280.,  32652.,  33024.,
      68685.,  69594.,  70503.,  71412.,  72942.,  73860.,  74778.,  75696.,
      77271.,  78198.,  79125.,  80052.,  81672.,  82608.,  83544.,  84480.,
      73365.,  74346.,  75327.,  76308.,  77910.,  78900.,  79890.,  80880.,
      82527.,  83526.,  84525.,  85524.,  87216.,  88224.,  89232.,  90240.,
      78045.,  79098.,  80151.,  81204.,  82878.,  83940.,  85002.,  86064.,
      87783.,  88854.,  89925.,  90996.,  92760.,  93840.,  94920.,  96000.,
      48306.,  49044.,  49782.,  50520.,  51624.,  52368.,  53112.,  53856.,
      54990.,  55740.,  56490.,  57240.,  58404.,  59160.,  59916.,  60672.,
      39214.,  40108.,  41002.,  41896.,  43060.,  43960.,  44860.,  45760.,
      46954.,  47860.,  48766.,  49672.,  50896.,  51808.,  52720.,  53632.,
      41182.,  42124.,  43066.,  44008.,  45220.,  46168.,  47116.,  48064.,
      49306.,  50260.,  51214.,  52168.,  53440.,  54400.,  55360.,  56320.,
      43150.,  44140.,  45130.,  46120.,  47380.,  48376.,  49372.,  50368.,
      51658.,  52660.,  53662.,  54664.,  55984.,  56992.,  58000.,  59008.,
      24172.,  24856.,  25540.,  26224.,  27056.,  27744.,  28432.,  29120.,
      29972.,  30664.,  31356.,  32048.,  32920.,  33616.,  34312.,  35008.,
      143565., 145626., 147687., 149748., 152430., 154500., 156570., 158640.,
      161367., 163446., 165525., 167604., 170376., 172464., 174552., 176640.,
      148245., 150378., 152511., 154644., 157398., 159540., 161682., 163824.,
      166623., 168774., 170925., 173076., 175920., 178080., 180240., 182400.,
      152925., 155130., 157335., 159540., 162366., 164580., 166794., 169008.,
      171879., 174102., 176325., 178548., 181464., 183696., 185928., 188160.,
      92082.,  93588.,  95094.,  96600.,  98472.,  99984.,  101496., 103008.,
      104910., 106428., 107946., 109464., 111396., 112920., 114444., 115968.,
      181005., 183642., 186279., 188916., 192174., 194820., 197466., 200112.,
      203415., 206070., 208725., 211380., 214728., 217392., 220056., 222720.,
      185685., 188394., 191103., 193812., 197142., 199860., 202578., 205296.,
      208671., 211398., 214125., 216852., 220272., 223008., 225744., 228480.,
      190365., 193146., 195927., 198708., 202110., 204900., 207690., 210480.,
      213927., 216726., 219525., 222324., 225816., 228624., 231432., 234240.,
      113970., 115860., 117750., 119640., 121896., 123792., 125688., 127584.,
      129870., 131772., 133674., 135576., 137892., 139800., 141708., 143616.,
      86446.,  88492.,  90538.,  92584.,  94900.,  96952.,  99004.,  101056.,
      103402., 105460., 107518., 109576., 111952., 114016., 116080., 118144.,
      88414.,  90508.,  92602.,  94696.,  97060.,  99160.,  101260., 103360.,
      105754., 107860., 109966., 112072., 114496., 116608., 118720., 120832.,
      90382.,  92524.,  94666.,  96808.,  99220.,  101368., 103516., 105664.,
      108106., 110260., 112414., 114568., 117040., 119200., 121360., 123520.,
      49516.,  50968.,  52420.,  53872.,  55472.,  56928.,  58384.,  59840.,
      61460.,  62920.,  64380.,  65840.,  67480.,  68944.,  70408.,  71872.,
      255885., 259674., 263463., 267252., 271662., 275460., 279258., 283056.,
      287511., 291318., 295125., 298932., 303432., 307248., 311064., 314880.,
      260565., 264426., 268287., 272148., 276630., 280500., 284370., 288240.,
      292767., 296646., 300525., 304404., 308976., 312864., 316752., 320640.,
      265245., 269178., 273111., 277044., 281598., 285540., 289482., 293424.,
      298023., 301974., 305925., 309876., 314520., 318480., 322440., 326400.,
      157746., 160404., 163062., 165720., 168744., 171408., 174072., 176736.,
      179790., 182460., 185130., 187800., 190884., 193560., 196236., 198912.,
      293325., 297690., 302055., 306420., 311406., 315780., 320154., 324528.,
      329559., 333942., 338325., 342708., 347784., 352176., 356568., 360960.,
      298005., 302442., 306879., 311316., 316374., 320820., 325266., 329712.,
      334815., 339270., 343725., 348180., 353328., 357792., 362256., 366720.,
      302685., 307194., 311703., 316212., 321342., 325860., 330378., 334896.,
      340071., 344598., 349125., 353652., 358872., 363408., 367944., 372480.,
      179634., 182676., 185718., 188760., 192168., 195216., 198264., 201312.,
      204750., 207804., 210858., 213912., 217380., 220440., 223500., 226560.,
      133678., 136876., 140074., 143272., 146740., 149944., 153148., 156352.,
      159850., 163060., 166270., 169480., 173008., 176224., 179440., 182656.,
      135646., 138892., 142138., 145384., 148900., 152152., 155404., 158656.,
      162202., 165460., 168718., 171976., 175552., 178816., 182080., 185344.,
      137614., 140908., 144202., 147496., 151060., 154360., 157660., 160960.,
      164554., 167860., 171166., 174472., 178096., 181408., 184720., 188032.,
      74860.,  77080.,  79300.,  81520.,  83888.,  86112.,  88336.,  90560.,
      92948.,  95176.,  97404.,  99632.,  102040., 104272., 106504., 108736.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31245.,  31578.,  31911.,  32244.,  33198.,  33540.,  33882.,  34224.,
      35223.,  35574.,  35925.,  36276.,  37320.,  37680.,  38040.,  38400.,
      35925.,  36330.,  36735.,  37140.,  38166.,  38580.,  38994.,  39408.,
      40479.,  40902.,  41325.,  41748.,  42864.,  43296.,  43728.,  44160.,
      40605.,  41082.,  41559.,  42036.,  43134.,  43620.,  44106.,  44592.,
      45735.,  46230.,  46725.,  47220.,  48408.,  48912.,  49416.,  49920.,
      68685.,  69594.,  70503.,  71412.,  72942.,  73860.,  74778.,  75696.,
      77271.,  78198.,  79125.,  80052.,  81672.,  82608.,  83544.,  84480.,
      73365.,  74346.,  75327.,  76308.,  77910.,  78900.,  79890.,  80880.,
      82527.,  83526.,  84525.,  85524.,  87216.,  88224.,  89232.,  90240.,
      78045.,  79098.,  80151.,  81204.,  82878.,  83940.,  85002.,  86064.,
      87783.,  88854.,  89925.,  90996.,  92760.,  93840.,  94920.,  96000.,
      143565., 145626., 147687., 149748., 152430., 154500., 156570., 158640.,
      161367., 163446., 165525., 167604., 170376., 172464., 174552., 176640.,
      148245., 150378., 152511., 154644., 157398., 159540., 161682., 163824.,
      166623., 168774., 170925., 173076., 175920., 178080., 180240., 182400.,
      152925., 155130., 157335., 159540., 162366., 164580., 166794., 169008.,
      171879., 174102., 176325., 178548., 181464., 183696., 185928., 188160.,
      181005., 183642., 186279., 188916., 192174., 194820., 197466., 200112.,
      203415., 206070., 208725., 211380., 214728., 217392., 220056., 222720.,
      185685., 188394., 191103., 193812., 197142., 199860., 202578., 205296.,
      208671., 211398., 214125., 216852., 220272., 223008., 225744., 228480.,
      190365., 193146., 195927., 198708., 202110., 204900., 207690., 210480.,
      213927., 216726., 219525., 222324., 225816., 228624., 231432., 234240.,
      255885., 259674., 263463., 267252., 271662., 275460., 279258., 283056.,
      287511., 291318., 295125., 298932., 303432., 307248., 311064., 314880.,
      260565., 264426., 268287., 272148., 276630., 280500., 284370., 288240.,
      292767., 296646., 300525., 304404., 308976., 312864., 316752., 320640.,
      265245., 269178., 273111., 277044., 281598., 285540., 289482., 293424.,
      298023., 301974., 305925., 309876., 314520., 318480., 322440., 326400.,
      293325., 297690., 302055., 306420., 311406., 315780., 320154., 324528.,
      329559., 333942., 338325., 342708., 347784., 352176., 356568., 360960.,
      298005., 302442., 306879., 311316., 316374., 320820., 325266., 329712.,
      334815., 339270., 343725., 348180., 353328., 357792., 362256., 366720.,
      302685., 307194., 311703., 316212., 321342., 325860., 330378., 334896.,
      340071., 344598., 349125., 353652., 358872., 363408., 367944., 372480.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      276.,  456.,  318.,  606.,  906.,  588.,  936.,  1356., 858.,
      560.,  772.,  460.,  1596., 2256., 1398., 1926., 2706., 1668.,
      2256., 3156., 1938., 1200., 1612., 940.,  2916., 4056., 2478.,
      3246., 4506., 2748., 3576., 4956., 3018., 1840., 2452., 1420.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      411.,  501.,  861.,  951.,  1311., 1401., 2211., 2301., 2661.,
      2751., 3111., 3201., 4011., 4101., 4461., 4551., 4911., 5001.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      513.,  552.,  840.,  912.,  579.,  636.,  1113., 1212., 1650.,
      1812., 1059., 1176., 1713., 1872., 2460., 2712., 1539., 1716.,
      984.,  1120., 1331., 1544., 772.,  920.,  2913., 3192., 4080.,
      4512., 2499., 2796., 3513., 3852., 4890., 5412., 2979., 3336.,
      4113., 4512., 5700., 6312., 3459., 3876., 2104., 2400., 2771.,
      3224., 1572., 1880., 5313., 5832., 7320., 8112., 4419., 4956.,
      5913., 6492., 8130., 9012., 4899., 5496., 6513., 7152., 8940.,
      9912., 5379., 6036., 3224., 3680., 4211., 4904., 2372., 2840.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  921.,  1002., 1569., 1722., 1731., 1902., 2379.,
      2622., 2541., 2802., 3999., 4422., 4161., 4602., 4809., 5322.,
      4971., 5502., 5619., 6222., 5781., 6402., 7239., 8022., 7401.,
      8202., 8049., 8922., 8211., 9102., 8859., 9822., 9021., 10002.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      987.,   1026.,  1065.,  1104.,  1608.,  1680.,  1752.,  1824.,  1101.,
      1158.,  1215.,  1272.,  2127.,  2226.,  2325.,  2424.,  3138.,  3300.,
      3462.,  3624.,  2001.,  2118.,  2235.,  2352.,  3267.,  3426.,  3585.,
      3744.,  4668.,  4920.,  5172.,  5424.,  2901.,  3078.,  3255.,  3432.,
      1832.,  1968.,  2104.,  2240.,  2449.,  2662.,  2875.,  3088.,  1396.,
      1544.,  1692.,  1840.,  5547.,  5826.,  6105.,  6384.,  7728.,  8160.,
      8592.,  9024.,  4701.,  4998.,  5295.,  5592.,  6687.,  7026.,  7365.,
      7704.,  9258.,  9780.,  10302., 10824., 5601.,  5958.,  6315.,  6672.,
      7827.,  8226.,  8625.,  9024.,  10788., 11400., 12012., 12624., 6501.,
      6918.,  7335.,  7752.,  3912.,  4208.,  4504.,  4800.,  5089.,  5542.,
      5995.,  6448.,  2836.,  3144.,  3452.,  3760.,  10107., 10626., 11145.,
      11664., 13848., 14640., 15432., 16224., 8301.,  8838.,  9375.,  9912.,
      11247., 11826., 12405., 12984., 15378., 16260., 17142., 18024., 9201.,
      9798.,  10395., 10992., 12387., 13026., 13665., 14304., 16908., 17880.,
      18852., 19824., 10101., 10758., 11415., 12072., 5992.,  6448.,  6904.,
      7360.,  7729.,  8422.,  9115.,  9808.,  4276.,  4744.,  5212.,  5680.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455.,  1518.,  1581.,  1644.,  1761.,  1842.,  1923.,  2004.,  2985.,
      3138.,  3291.,  3444.,  3291.,  3462.,  3633.,  3804.,  4515.,  4758.,
      5001.,  5244.,  4821.,  5082.,  5343.,  5604.,  7575.,  7998.,  8421.,
      8844.,  7881.,  8322.,  8763.,  9204.,  9105.,  9618.,  10131., 10644.,
      9411.,  9942.,  10473., 11004., 10635., 11238., 11841., 12444., 10941.,
      11562., 12183., 12804., 13695., 14478., 15261., 16044., 14001., 14802.,
      15603., 16404., 15225., 16098., 16971., 17844., 15531., 16422., 17313.,
      18204., 16755., 17718., 18681., 19644., 17061., 18042., 19023., 20004.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      966.,   1104.,  1599.,  1824.,  1110.,  1272.,  2166.,  2424.,  3219.,
      3624.,  2070.,  2352.,  3366.,  3744.,  4839.,  5424.,  3030.,  3432.,
      1940.,  2240.,  2626.,  3088.,  1524.,  1840.,  5766.,  6384.,  8079.,
      9024.,  4950.,  5592.,  6966.,  7704.,  9699.,  10824., 5910.,  6672.,
      8166.,  9024.,  11319., 12624., 6870.,  7752.,  4180.,  4800.,  5506.,
      6448.,  3124.,  3760.,  10566., 11664., 14559., 16224., 8790.,  9912.,
      11766., 12984., 16179., 18024., 9750.,  10992., 12966., 14304., 17799.,
      19824., 10710., 12072., 6420.,  7360.,  8386.,  9808.,  4724.,  5680.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1437.,  1644.,  1761.,  2004.,  3057.,  3444.,  3381.,  3804.,  4677.,
      5244.,  5001.,  5604.,  7917.,  8844.,  8241.,  9204.,  9537.,  10644.,
      9861.,  11004., 11157., 12444., 11481., 12804., 14397., 16044., 14721.,
      16404., 16017., 17844., 16341., 18204., 17637., 19644., 17961., 20004.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1860.,  1932.,  2130.,  2208.,  3063.,  3198.,  3504.,  3648.,  2112.,
      2220.,  2430.,  2544.,  4140.,  4332.,  4650.,  4848.,  6123.,  6438.,
      6924.,  7248.,  3912.,  4140.,  4470.,  4704.,  6420.,  6732.,  7170.,
      7488.,  9183.,  9678.,  10344., 10848., 5712.,  6060.,  6510.,  6864.,
      3612.,  3880.,  4208.,  4480.,  4832.,  5252.,  5750.,  6176.,  2756.,
      3048.,  3384.,  3680.,  10980., 11532., 12210., 12768., 15303., 16158.,
      17184., 18048., 9312.,  9900.,  10590., 11184., 13260., 13932., 14730.,
      15408., 18363., 19398., 20604., 21648., 11112., 11820., 12630., 13344.,
      15540., 16332., 17250., 18048., 21423., 22638., 24024., 25248., 12912.,
      13740., 14670., 15504., 7772.,  8360.,  9008.,  9600.,  10112., 11012.,
      11990., 12896., 5636.,  6248.,  6904.,  7520.,  20100., 21132., 22290.,
      23328., 27543., 29118., 30864., 32448., 16512., 17580., 18750., 19824.,
      22380., 23532., 24810., 25968., 30603., 32358., 34284., 36048., 18312.,
      19500., 20790., 21984., 24660., 25932., 27330., 28608., 33663., 35598.,
      37704., 39648., 20112., 21420., 22830., 24144., 11932., 12840., 13808.,
      14720., 15392., 16772., 18230., 19616., 8516.,  9448.,  10424., 11360.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2757.,  2874.,  3162.,  3288.,  3369.,  3522.,  3846.,  4008.,  5817.,
      6114.,  6582.,  6888.,  6429.,  6762.,  7266.,  7608.,  8877.,  9354.,
      10002., 10488., 9489.,  10002., 10686., 11208., 14997., 15834., 16842.,
      17688., 15609., 16482., 17526., 18408., 18057., 19074., 20262., 21288.,
      18669., 19722., 20946., 22008., 21117., 22314., 23682., 24888., 21729.,
      22962., 24366., 25608., 27237., 28794., 30522., 32088., 27849., 29442.,
      31206., 32808., 30297., 32034., 33942., 35688., 30909., 32682., 34626.,
      36408., 33357., 35274., 37362., 39288., 33969., 35922., 38046., 40008.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3648.,  3720.,  3792.,  3864.,  4182.,  4260.,  4338.,  4416.,  5991.,
      6126.,  6261.,  6396.,  6864.,  7008.,  7152.,  7296.,  4116.,  4224.,
      4332.,  4440.,  4746.,  4860.,  4974.,  5088.,  8088.,  8280.,  8472.,
      8664.,  9102.,  9300.,  9498.,  9696.,  11931., 12246., 12561., 12876.,
      13524., 13848., 14172., 14496., 7596.,  7824.,  8052.,  8280.,  8706.,
      8940.,  9174.,  9408.,  12528., 12840., 13152., 13464., 14022., 14340.,
      14658., 14976., 17871., 18366., 18861., 19356., 20184., 20688., 21192.,
      21696., 11076., 11424., 11772., 12120., 12666., 13020., 13374., 13728.,
      6956.,  7224.,  7492.,  7760.,  8144.,  8416.,  8688.,  8960.,  9244.,
      9664.,  10084., 10504., 11074., 11500., 11926., 12352., 5220.,  5512.,
      5804.,  6096.,  6472.,  6768.,  7064.,  7360.,  21408., 21960., 22512.,
      23064., 23862., 24420., 24978., 25536., 29751., 30606., 31461., 32316.,
      33504., 34368., 35232., 36096., 18036., 18624., 19212., 19800., 20586.,
      21180., 21774., 22368., 25848., 26520., 27192., 27864., 28782., 29460.,
      30138., 30816., 35691., 36726., 37761., 38796., 40164., 41208., 42252.,
      43296., 21516., 22224., 22932., 23640., 24546., 25260., 25974., 26688.,
      30288., 31080., 31872., 32664., 33702., 34500., 35298., 36096., 41631.,
      42846., 44061., 45276., 46824., 48048., 49272., 50496., 24996., 25824.,
      26652., 27480., 28506., 29340., 30174., 31008., 14956., 15544., 16132.,
      16720., 17424., 18016., 18608., 19200., 19324., 20224., 21124., 22024.,
      23074., 23980., 24886., 25792., 10660., 11272., 11884., 12496., 13192.,
      13808., 14424., 15040., 39168., 40200., 41232., 42264., 43542., 44580.,
      45618., 46656., 53511., 55086., 56661., 58236., 60144., 61728., 63312.,
      64896., 31956., 33024., 34092., 35160., 36426., 37500., 38574., 39648.,
      43608., 44760., 45912., 47064., 48462., 49620., 50778., 51936., 59451.,
      61206., 62961., 64716., 66804., 68568., 70332., 72096., 35436., 36624.,
      37812., 39000., 40386., 41580., 42774., 43968., 48048., 49320., 50592.,
      51864., 53382., 54660., 55938., 57216., 65391., 67326., 69261., 71196.,
      73464., 75408., 77352., 79296., 38916., 40224., 41532., 42840., 44346.,
      45660., 46974., 48288., 22956., 23864., 24772., 25680., 26704., 27616.,
      28528., 29440., 29404., 30784., 32164., 33544., 35074., 36460., 37846.,
      39232., 16100., 17032., 17964., 18896., 19912., 20848., 21784., 22720.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5397.,  5514.,  5631.,  5748.,  6198.,  6324.,  6450.,  6576.,  6585.,
      6738.,  6891.,  7044.,  7530.,  7692.,  7854.,  8016.,  11337., 11634.,
      11931., 12228., 12858., 13164., 13470., 13776., 12525., 12858., 13191.,
      13524., 14190., 14532., 14874., 15216., 17277., 17754., 18231., 18708.,
      19518., 20004., 20490., 20976., 18465., 18978., 19491., 20004., 20850.,
      21372., 21894., 22416., 29157., 29994., 30831., 31668., 32838., 33684.,
      34530., 35376., 30345., 31218., 32091., 32964., 34170., 35052., 35934.,
      36816., 35097., 36114., 37131., 38148., 39498., 40524., 41550., 42576.,
      36285., 37338., 38391., 39444., 40830., 41892., 42954., 44016., 41037.,
      42234., 43431., 44628., 46158., 47364., 48570., 49776., 42225., 43458.,
      44691., 45924., 47490., 48732., 49974., 51216., 52917., 54474., 56031.,
      57588., 59478., 61044., 62610., 64176., 54105., 55698., 57291., 58884.,
      60810., 62412., 64014., 65616., 58857., 60594., 62331., 64068., 66138.,
      67884., 69630., 71376., 60045., 61818., 63591., 65364., 67470., 69252.,
      71034., 72816., 64797., 66714., 68631., 70548., 72798., 74724., 76650.,
      78576., 65985., 67938., 69891., 71844., 74130., 76092., 78054., 80016.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3606.,  3864.,  4134.,  4416.,  5973.,  6396.,  6837.,  7296.,  4134.,
      4440.,  4758.,  5088.,  8166.,  8664.,  9174.,  9696.,  12093., 12876.,
      13677., 14496., 7734.,  8280.,  8838.,  9408.,  12726., 13464., 14214.,
      14976., 18213., 19356., 20517., 21696., 11334., 12120., 12918., 13728.,
      7172.,  7760.,  8356.,  8960.,  9598.,  10504., 11422., 12352., 5476.,
      6096.,  6724.,  7360.,  21846., 23064., 24294., 25536., 30453., 32316.,
      34197., 36096., 18534., 19800., 21078., 22368., 26406., 27864., 29334.,
      30816., 36573., 38796., 41037., 43296., 22134., 23640., 25158., 26688.,
      30966., 32664., 34374., 36096., 42693., 45276., 47877., 50496., 25734.,
      27480., 29238., 31008., 15492., 16720., 17956., 19200., 20158., 22024.,
      23902., 25792., 11236., 12496., 13764., 15040., 40086., 42264., 44454.,
      46656., 54933., 58236., 61557., 64896., 32934., 35160., 37398., 39648.,
      44646., 47064., 49494., 51936., 61053., 64716., 68397., 72096., 36534.,
      39000., 41478., 43968., 49206., 51864., 54534., 57216., 67173., 71196.,
      75237., 79296., 40134., 42840., 45558., 48288., 23812., 25680., 27556.,
      29440., 30718., 33544., 36382., 39232., 16996., 18896., 20804., 22720.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5361.,  5748.,  6153.,  6576.,  6585.,  7044.,  7521.,  8016.,  11481.,
      12228., 12993., 13776., 12705., 13524., 14361., 15216., 17601., 18708.,
      19833., 20976., 18825., 20004., 21201., 22416., 29841., 31668., 33513.,
      35376., 31065., 32964., 34881., 36816., 35961., 38148., 40353., 42576.,
      37185., 39444., 41721., 44016., 42081., 44628., 47193., 49776., 43305.,
      45924., 48561., 51216., 54321., 57588., 60873., 64176., 55545., 58884.,
      62241., 65616., 60441., 64068., 67713., 71376., 61665., 65364., 69081.,
      72816., 66561., 70548., 74553., 78576., 67785., 71844., 75921., 80016.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7074.,   7212.,   7584.,   7728.,   8118.,   8268.,   8676.,   8832.,
      11685.,  11946.,  12522.,  12792.,  13395.,  13674.,  14304.,  14592.,
      8058.,   8268.,   8664.,   8880.,   9294.,   9516.,   9948.,   10176.,
      15954.,  16332.,  16944.,  17328.,  17958.,  18348.,  18996.,  19392.,
      23565.,  24186.,  25122.,  25752.,  26715.,  27354.,  28344.,  28992.,
      15018.,  15468.,  16104.,  16560.,  17214.,  17676.,  18348.,  18816.,
      24834.,  25452.,  26304.,  26928.,  27798.,  28428.,  29316.,  29952.,
      35445.,  36426.,  37722.,  38712.,  40035.,  41034.,  42384.,  43392.,
      21978.,  22668.,  23544.,  24240.,  25134.,  25836.,  26748.,  27456.,
      13812.,  14344.,  14984.,  15520.,  16172.,  16712.,  17376.,  17920.,
      18362.,  19196.,  20168.,  21008.,  21998.,  22844.,  23852.,  24704.,
      10372.,  10952.,  11608.,  12192.,  12860.,  13448.,  14128.,  14720.,
      42594.,  43692.,  45024.,  46128.,  47478.,  48588.,  49956.,  51072.,
      59205.,  60906.,  62922.,  64632.,  66675.,  68394.,  70464.,  72192.,
      35898.,  37068.,  38424.,  39600.,  40974.,  42156.,  43548.,  44736.,
      51474.,  52812.,  54384.,  55728.,  57318.,  58668.,  60276.,  61632.,
      71085.,  73146.,  75522.,  77592.,  79995.,  82074.,  84504.,  86592.,
      42858.,  44268.,  45864.,  47280.,  48894.,  50316.,  51948.,  53376.,
      60354.,  61932.,  63744.,  65328.,  67158.,  68748.,  70596.,  72192.,
      82965.,  85386.,  88122.,  90552.,  93315.,  95754.,  98544.,  100992.,
      49818.,  51468.,  53304.,  54960.,  56814.,  58476.,  60348.,  62016.,
      29812.,  30984.,  32264.,  33440.,  34732.,  35912.,  37216.,  38400.,
      38522.,  40316.,  42248.,  44048.,  45998.,  47804.,  49772.,  51584.,
      21252.,  22472.,  23768.,  24992.,  26300.,  27528.,  28848.,  30080.,
      78114.,  80172.,  82464.,  84528.,  86838.,  88908.,  91236.,  93312.,
      106725., 109866., 113322., 116472., 119955., 123114., 126624., 129792.,
      63738.,  65868.,  68184.,  70320.,  72654.,  74796.,  77148.,  79296.,
      86994.,  89292.,  91824.,  94128.,  96678.,  98988.,  101556., 103872.,
      118605., 122106., 125922., 129432., 133275., 136794., 140664., 144192.,
      70698.,  73068.,  75624.,  78000.,  80574.,  82956.,  85548.,  87936.,
      95874.,  98412.,  101184., 103728., 106518., 109068., 111876., 114432.,
      130485., 134346., 138522., 142392., 146595., 150474., 154704., 158592.,
      77658.,  80268.,  83064.,  85680.,  88494.,  91116.,  93948.,  96576.,
      45812.,  47624.,  49544.,  51360.,  53292.,  55112.,  57056.,  58880.,
      58682.,  61436.,  64328.,  67088.,  69998.,  72764.,  75692.,  78464.,
      32132.,  33992.,  35928.,  37792.,  39740.,  41608.,  43568.,  45440.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10497.,  10722.,  11262.,  11496.,  12063.,  12306.,  12900.,  13152.,
      12873.,  13170.,  13782.,  14088.,  14727.,  15042.,  15708.,  16032.,
      22377.,  22962.,  23862.,  24456.,  25383.,  25986.,  26940.,  27552.,
      24753.,  25410.,  26382.,  27048.,  28047.,  28722.,  29748.,  30432.,
      34257.,  35202.,  36462.,  37416.,  38703.,  39666.,  40980.,  41952.,
      36633.,  37650.,  38982.,  40008.,  41367.,  42402.,  43788.,  44832.,
      58017.,  59682.,  61662.,  63336.,  65343.,  67026.,  69060.,  70752.,
      60393.,  62130.,  64182.,  65928.,  68007.,  69762.,  71868.,  73632.,
      69897.,  71922.,  74262.,  76296.,  78663.,  80706.,  83100.,  85152.,
      72273.,  74370.,  76782.,  78888.,  81327.,  83442.,  85908.,  88032.,
      81777.,  84162.,  86862.,  89256.,  91983.,  94386.,  97140.,  99552.,
      84153.,  86610.,  89382.,  91848.,  94647.,  97122.,  99948.,  102432.,
      105537., 108642., 112062., 115176., 118623., 121746., 125220., 128352.,
      107913., 111090., 114582., 117768., 121287., 124482., 128028., 131232.,
      117417., 120882., 124662., 128136., 131943., 135426., 139260., 142752.,
      119793., 123330., 127182., 130728., 134607., 138162., 142068., 145632.,
      129297., 133122., 137262., 141096., 145263., 149106., 153300., 157152.,
      131673., 135570., 139782., 143688., 147927., 151842., 156108., 160032.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14010.,  14148.,  14286.,  14424.,  15024.,  15168.,  15312.,  15456.,
      16086.,  16236.,  16386.,  16536.,  17196.,  17352.,  17508.,  17664.,
      23109.,  23370.,  23631.,  23892.,  24774.,  25044.,  25314.,  25584.,
      26511.,  26790.,  27069.,  27348.,  28320.,  28608.,  28896.,  29184.,
      15906.,  16116.,  16326.,  16536.,  17112.,  17328.,  17544.,  17760.,
      18366.,  18588.,  18810.,  19032.,  19668.,  19896.,  20124.,  20352.,
      31530.,  31908.,  32286.,  32664.,  33504.,  33888.,  34272.,  34656.,
      35526.,  35916.,  36306.,  36696.,  37596.,  37992.,  38388.,  38784.,
      46509.,  47130.,  47751.,  48372.,  49614.,  50244.,  50874.,  51504.,
      52791.,  53430.,  54069.,  54708.,  56040.,  56688.,  57336.,  57984.,
      29586.,  30036.,  30486.,  30936.,  31752.,  32208.,  32664.,  33120.,
      33966.,  34428.,  34890.,  35352.,  36228.,  36696.,  37164.,  37632.,
      49050.,  49668.,  50286.,  50904.,  51984.,  52608.,  53232.,  53856.,
      54966.,  55596.,  56226.,  56856.,  57996.,  58632.,  59268.,  59904.,
      69909.,  70890.,  71871.,  72852.,  74454.,  75444.,  76434.,  77424.,
      79071.,  80070.,  81069.,  82068.,  83760.,  84768.,  85776.,  86784.,
      43266.,  43956.,  44646.,  45336.,  46392.,  47088.,  47784.,  48480.,
      49566.,  50268.,  50970.,  51672.,  52788.,  53496.,  54204.,  54912.,
      27092.,  27624.,  28156.,  28688.,  29432.,  29968.,  30504.,  31040.,
      31804.,  32344.,  32884.,  33424.,  34208.,  34752.,  35296.,  35840.,
      35890.,  36724.,  37558.,  38392.,  39496.,  40336.,  41176.,  42016.,
      43150.,  43996.,  44842.,  45688.,  46852.,  47704.,  48556.,  49408.,
      20164.,  20744.,  21324.,  21904.,  22632.,  23216.,  23800.,  24384.,
      25132.,  25720.,  26308.,  26896.,  27664.,  28256.,  28848.,  29440.,
      84090.,  85188.,  86286.,  87384.,  88944.,  90048.,  91152.,  92256.,
      93846.,  94956.,  96066.,  97176.,  98796.,  99912.,  101028., 102144.,
      116709., 118410., 120111., 121812., 124134., 125844., 127554., 129264.,
      131631., 133350., 135069., 136788., 139200., 140928., 142656., 144384.,
      70626.,  71796.,  72966.,  74136.,  75672.,  76848.,  78024.,  79200.,
      80766.,  81948.,  83130.,  84312.,  85908.,  87096.,  88284.,  89472.,
      101610., 102948., 104286., 105624., 107424., 108768., 110112., 111456.,
      113286., 114636., 115986., 117336., 119196., 120552., 121908., 123264.,
      140109., 142170., 144231., 146292., 148974., 151044., 153114., 155184.,
      157911., 159990., 162069., 164148., 166920., 169008., 171096., 173184.,
      84306.,  85716.,  87126.,  88536.,  90312.,  91728.,  93144.,  94560.,
      96366.,  97788.,  99210.,  100632., 102468., 103896., 105324., 106752.,
      119130., 120708., 122286., 123864., 125904., 127488., 129072., 130656.,
      132726., 134316., 135906., 137496., 139596., 141192., 142788., 144384.,
      163509., 165930., 168351., 170772., 173814., 176244., 178674., 181104.,
      184191., 186630., 189069., 191508., 194640., 197088., 199536., 201984.,
      97986.,  99636.,  101286., 102936., 104952., 106608., 108264., 109920.,
      111966., 113628., 115290., 116952., 119028., 120696., 122364., 124032.,
      58452.,  59624.,  60796.,  61968.,  63352.,  64528.,  65704.,  66880.,
      68284.,  69464.,  70644.,  71824.,  73248.,  74432.,  75616.,  76800.,
      75250.,  77044.,  78838.,  80632.,  82696.,  84496.,  86296.,  88096.,
      90190.,  91996.,  93802.,  95608.,  97732.,  99544.,  101356., 103168.,
      41284.,  42504.,  43724.,  44944.,  46312.,  47536.,  48760.,  49984.,
      51372.,  52600.,  53828.,  55056.,  56464.,  57696.,  58928.,  60160.,
      154170., 156228., 158286., 160344., 162864., 164928., 166992., 169056.,
      171606., 173676., 175746., 177816., 180396., 182472., 184548., 186624.,
      210309., 213450., 216591., 219732., 223494., 226644., 229794., 232944.,
      236751., 239910., 243069., 246228., 250080., 253248., 256416., 259584.,
      125346., 127476., 129606., 131736., 134232., 136368., 138504., 140640.,
      143166., 145308., 147450., 149592., 152148., 154296., 156444., 158592.,
      171690., 173988., 176286., 178584., 181344., 183648., 185952., 188256.,
      191046., 193356., 195666., 197976., 200796., 203112., 205428., 207744.,
      233709., 237210., 240711., 244212., 248334., 251844., 255354., 258864.,
      263031., 266550., 270069., 273588., 277800., 281328., 284856., 288384.,
      139026., 141396., 143766., 146136., 148872., 151248., 153624., 156000.,
      158766., 161148., 163530., 165912., 168708., 171096., 173484., 175872.,
      189210., 191748., 194286., 196824., 199824., 202368., 204912., 207456.,
      210486., 213036., 215586., 218136., 221196., 223752., 226308., 228864.,
      257109., 260970., 264831., 268692., 273174., 277044., 280914., 284784.,
      289311., 293190., 297069., 300948., 305520., 309408., 313296., 317184.,
      152706., 155316., 157926., 160536., 163512., 166128., 168744., 171360.,
      174366., 176988., 179610., 182232., 185268., 187896., 190524., 193152.,
      89812.,  91624.,  93436.,  95248.,  97272.,  99088.,  100904., 102720.,
      104764., 106584., 108404., 110224., 112288., 114112., 115936., 117760.,
      114610., 117364., 120118., 122872., 125896., 128656., 131416., 134176.,
      137230., 139996., 142762., 145528., 148612., 151384., 154156., 156928.,
      62404.,  64264.,  66124.,  67984.,  69992.,  71856.,  73720.,  75584.,
      77612.,  79480.,  81348.,  83216.,  85264.,  87136.,  89008.,  90880.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20769.,  20994.,  21219.,  21444.,  22290.,  22524.,  22758.,  22992.,
      23883.,  24126.,  24369.,  24612.,  25548.,  25800.,  26052.,  26304.,
      25449.,  25746.,  26043.,  26340.,  27258.,  27564.,  27870.,  28176.,
      29139.,  29454.,  29769.,  30084.,  31092.,  31416.,  31740.,  32064.,
      44169.,  44754.,  45339.,  45924.,  47130.,  47724.,  48318.,  48912.,
      50163.,  50766.,  51369.,  51972.,  53268.,  53880.,  54492.,  55104.,
      48849.,  49506.,  50163.,  50820.,  52098.,  52764.,  53430.,  54096.,
      55419.,  56094.,  56769.,  57444.,  58812.,  59496.,  60180.,  60864.,
      67569.,  68514.,  69459.,  70404.,  71970.,  72924.,  73878.,  74832.,
      76443.,  77406.,  78369.,  79332.,  80988.,  81960.,  82932.,  83904.,
      72249.,  73266.,  74283.,  75300.,  76938.,  77964.,  78990.,  80016.,
      81699.,  82734.,  83769.,  84804.,  86532.,  87576.,  88620.,  89664.,
      114369., 116034., 117699., 119364., 121650., 123324., 124998., 126672.,
      129003., 130686., 132369., 134052., 136428., 138120., 139812., 141504.,
      119049., 120786., 122523., 124260., 126618., 128364., 130110., 131856.,
      134259., 136014., 137769., 139524., 141972., 143736., 145500., 147264.,
      137769., 139794., 141819., 143844., 146490., 148524., 150558., 152592.,
      155283., 157326., 159369., 161412., 164148., 166200., 168252., 170304.,
      142449., 144546., 146643., 148740., 151458., 153564., 155670., 157776.,
      160539., 162654., 164769., 166884., 169692., 171816., 173940., 176064.,
      161169., 163554., 165939., 168324., 171330., 173724., 176118., 178512.,
      181563., 183966., 186369., 188772., 191868., 194280., 196692., 199104.,
      165849., 168306., 170763., 173220., 176298., 178764., 181230., 183696.,
      186819., 189294., 191769., 194244., 197412., 199896., 202380., 204864.,
      207969., 211074., 214179., 217284., 221010., 224124., 227238., 230352.,
      234123., 237246., 240369., 243492., 247308., 250440., 253572., 256704.,
      212649., 215826., 219003., 222180., 225978., 229164., 232350., 235536.,
      239379., 242574., 245769., 248964., 252852., 256056., 259260., 262464.,
      231369., 234834., 238299., 241764., 245850., 249324., 252798., 256272.,
      260403., 263886., 267369., 270852., 275028., 278520., 282012., 285504.,
      236049., 239586., 243123., 246660., 250818., 254364., 257910., 261456.,
      265659., 269214., 272769., 276324., 280572., 284136., 287700., 291264.,
      254769., 258594., 262419., 266244., 270690., 274524., 278358., 282192.,
      286683., 290526., 294369., 298212., 302748., 306600., 310452., 314304.,
      259449., 263346., 267243., 271140., 275658., 279564., 283470., 287376.,
      291939., 295854., 299769., 303684., 308292., 312216., 316140., 320064.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474.,  564.,  384.,  1014., 1104., 708.,  1554., 1644., 1032.,
      892.,  934.,  553.,  2634., 2724., 1680., 3174., 3264., 2004.,
      3714., 3804., 2328., 1900., 1942., 1129., 4794., 4884., 2976.,
      5334., 5424., 3300., 5874., 5964., 3624., 2908., 2950., 1705.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474.,  564.,  1014., 1104., 1554., 1644., 2634., 2724., 3174.,
      3264., 3714., 3804., 4794., 4884., 5334., 5424., 5874., 5964.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,   948.,   1038., 1128.,  699.,  768.,  1848.,  2028.,  2010.,
      2208.,  1275.,  1416., 2820.,  3108., 2982., 3288.,  1851.,  2064.,
      1538.,  1784.,  1610., 1868.,  928.,  1106., 4764.,  5268.,  4926.,
      5448.,  3003.,  3360., 5736.,  6348., 5898., 6528.,  3579.,  4008.,
      6708.,  7428.,  6870., 7608.,  4155., 4656., 3266.,  3800.,  3338.,
      3884.,  1888.,  2258., 8652.,  9588., 8814., 9768.,  5307.,  5952.,
      9624.,  10668., 9786., 10848., 5883., 6600., 10596., 11748., 10758.,
      11928., 6459.,  7248., 4994.,  5816., 5066., 5900.,  2848.,  3410.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038.,  1128., 1848.,  2028.,  2010.,  2208.,  2820.,
      3108., 2982., 3288.,  4764., 5268.,  4926.,  5448.,  5736.,  6348.,
      5898., 6528., 6708.,  7428., 6870.,  7608.,  8652.,  9588.,  8814.,
      9768., 9624., 10668., 9786., 10848., 10596., 11748., 10758., 11928.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1986.,  2076.,  2166.,  2256.,  1329.,
      1398.,  1467.,  1536.,  3516.,  3696.,  3876.,  4056.,  3822.,  4020.,
      4218.,  4416.,  2409.,  2550.,  2691.,  2832.,  5352.,  5640.,  5928.,
      6216.,  5658.,  5964.,  6270.,  6576.,  3489.,  3702.,  3915.,  4128.,
      2830.,  3076.,  3322.,  3568.,  2962.,  3220.,  3478.,  3736.,  1678.,
      1856.,  2034.,  2212.,  9024.,  9528.,  10032., 10536., 9330.,  9852.,
      10374., 10896., 5649.,  6006.,  6363.,  6720.,  10860., 11472., 12084.,
      12696., 11166., 11796., 12426., 13056., 6729.,  7158.,  7587.,  8016.,
      12696., 13416., 14136., 14856., 13002., 13740., 14478., 15216., 7809.,
      8310.,  8811.,  9312.,  5998.,  6532.,  7066.,  7600.,  6130.,  6676.,
      7222.,  7768.,  3406.,  3776.,  4146.,  4516.,  16368., 17304., 18240.,
      19176., 16674., 17628., 18582., 19536., 9969.,  10614., 11259., 11904.,
      18204., 19248., 20292., 21336., 18510., 19572., 20634., 21696., 11049.,
      11766., 12483., 13200., 20040., 21192., 22344., 23496., 20346., 21516.,
      22686., 23856., 12129., 12918., 13707., 14496., 9166.,  9988.,  10810.,
      11632., 9298.,  10132., 10966., 11800., 5134.,  5696.,  6258.,  6820.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1986.,  2076.,  2166.,  2256.,  3516.,
      3696.,  3876.,  4056.,  3822.,  4020.,  4218.,  4416.,  5352.,  5640.,
      5928.,  6216.,  5658.,  5964.,  6270.,  6576.,  9024.,  9528.,  10032.,
      10536., 9330.,  9852.,  10374., 10896., 10860., 11472., 12084., 12696.,
      11166., 11796., 12426., 13056., 12696., 13416., 14136., 14856., 13002.,
      13740., 14478., 15216., 16368., 17304., 18240., 19176., 16674., 17628.,
      18582., 19536., 18204., 19248., 20292., 21336., 18510., 19572., 20634.,
      21696., 20040., 21192., 22344., 23496., 20346., 21516., 22686., 23856.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1671.,  1896.,  1995.,  2256.,  1350.,  1536.,  3615.,  4056.,  3939.,
      4416.,  2502.,  2832.,  5559.,  6216.,  5883.,  6576.,  3654.,  4128.,
      3040.,  3568.,  3184.,  3736.,  1836.,  2212.,  9447.,  10536., 9771.,
      10896., 5958.,  6720.,  11391., 12696., 11715., 13056., 7110.,  8016.,
      13335., 14856., 13659., 15216., 8262.,  9312.,  6496.,  7600.,  6640.,
      7768.,  3756.,  4516.,  17223., 19176., 17547., 19536., 10566., 11904.,
      19167., 21336., 19491., 21696., 11718., 13200., 21111., 23496., 21435.,
      23856., 12870., 14496., 9952.,  11632., 10096., 11800., 5676.,  6820.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1671.,  1896.,  1995.,  2256.,  3615.,  4056.,  3939.,  4416.,  5559.,
      6216.,  5883.,  6576.,  9447.,  10536., 9771.,  10896., 11391., 12696.,
      11715., 13056., 13335., 14856., 13659., 15216., 17223., 19176., 17547.,
      19536., 19167., 21336., 19491., 21696., 21111., 23496., 21435., 23856.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207.,  3342.,  3648.,  3792.,  3819.,  3990.,  4332.,  4512.,  2568.,
      2700.,  2934.,  3072.,  6879.,  7230.,  7752.,  8112.,  7491.,  7878.,
      8436.,  8832.,  4728.,  5004.,  5382.,  5664.,  10551., 11118., 11856.,
      12432., 11163., 11766., 12540., 13152., 6888.,  7308.,  7830.,  8256.,
      5594.,  6080.,  6644.,  7136.,  5858.,  6368.,  6956.,  7472.,  3320.,
      3672.,  4068.,  4424.,  17895., 18894., 20064., 21072., 18507., 19542.,
      20748., 21792., 11208., 11916., 12726., 13440., 21567., 22782., 24168.,
      25392., 22179., 23430., 24852., 26112., 13368., 14220., 15174., 16032.,
      25239., 26670., 28272., 29712., 25851., 27318., 28956., 30432., 15528.,
      16524., 17622., 18624., 11930., 12992., 14132., 15200., 12194., 13280.,
      14444., 15536., 6776.,  7512.,  8292.,  9032.,  32583., 34446., 36480.,
      38352., 33195., 35094., 37164., 39072., 19848., 21132., 22518., 23808.,
      36255., 38334., 40584., 42672., 36867., 38982., 41268., 43392., 22008.,
      23436., 24966., 26400., 39927., 42222., 44688., 46992., 40539., 42870.,
      45372., 47712., 24168., 25740., 27414., 28992., 18266., 19904., 21620.,
      23264., 18530., 20192., 21932., 23600., 10232., 11352., 12516., 13640.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207.,  3342.,  3648.,  3792.,  3819.,  3990.,  4332.,  4512.,  6879.,
      7230.,  7752.,  8112.,  7491.,  7878.,  8436.,  8832.,  10551., 11118.,
      11856., 12432., 11163., 11766., 12540., 13152., 17895., 18894., 20064.,
      21072., 18507., 19542., 20748., 21792., 21567., 22782., 24168., 25392.,
      22179., 23430., 24852., 26112., 25239., 26670., 28272., 29712., 25851.,
      27318., 28956., 30432., 32583., 34446., 36480., 38352., 33195., 35094.,
      37164., 39072., 36255., 38334., 40584., 42672., 36867., 38982., 41268.,
      43392., 39927., 42222., 44688., 46992., 40539., 42870., 45372., 47712.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6279.,  6414.,  6549.,  6684.,  7152.,  7296.,  7440.,  7584.,  7467.,
      7638.,  7809.,  7980.,  8484.,  8664.,  8844.,  9024.,  5004.,  5136.,
      5268.,  5400.,  5730.,  5868.,  6006.,  6144.,  13407., 13758., 14109.,
      14460., 15144., 15504., 15864., 16224., 14595., 14982., 15369., 15756.,
      16476., 16872., 17268., 17664., 9180.,  9456.,  9732.,  10008., 10482.,
      10764., 11046., 11328., 20535., 21102., 21669., 22236., 23136., 23712.,
      24288., 24864., 21723., 22326., 22929., 23532., 24468., 25080., 25692.,
      26304., 13356., 13776., 14196., 14616., 15234., 15660., 16086., 16512.,
      10702., 11188., 11674., 12160., 12796., 13288., 13780., 14272., 11206.,
      11716., 12226., 12736., 13396., 13912., 14428., 14944., 6288.,  6640.,
      6992.,  7344.,  7780.,  8136.,  8492.,  8848.,  34791., 35790., 36789.,
      37788., 39120., 40128., 41136., 42144., 35979., 37014., 38049., 39084.,
      40452., 41496., 42540., 43584., 21708., 22416., 23124., 23832., 24738.,
      25452., 26166., 26880., 41919., 43134., 44349., 45564., 47112., 48336.,
      49560., 50784., 43107., 44358., 45609., 46860., 48444., 49704., 50964.,
      52224., 25884., 26736., 27588., 28440., 29490., 30348., 31206., 32064.,
      49047., 50478., 51909., 53340., 55104., 56544., 57984., 59424., 50235.,
      51702., 53169., 54636., 56436., 57912., 59388., 60864., 30060., 31056.,
      32052., 33048., 34242., 35244., 36246., 37248., 22798., 23860., 24922.,
      25984., 27196., 28264., 29332., 30400., 23302., 24388., 25474., 26560.,
      27796., 28888., 29980., 31072., 12816., 13552., 14288., 15024., 15844.,
      16584., 17324., 18064., 63303., 65166., 67029., 68892., 71088., 72960.,
      74832., 76704., 64491., 66390., 68289., 70188., 72420., 74328., 76236.,
      78144., 38412., 39696., 40980., 42264., 43746., 45036., 46326., 47616.,
      70431., 72510., 74589., 76668., 79080., 81168., 83256., 85344., 71619.,
      73734., 75849., 77964., 80412., 82536., 84660., 86784., 42588., 44016.,
      45444., 46872., 48498., 49932., 51366., 52800., 77559., 79854., 82149.,
      84444., 87072., 89376., 91680., 93984., 78747., 81078., 83409., 85740.,
      88404., 90744., 93084., 95424., 46764., 48336., 49908., 51480., 53250.,
      54828., 56406., 57984., 34894., 36532., 38170., 39808., 41596., 43240.,
      44884., 46528., 35398., 37060., 38722., 40384., 42196., 43864., 45532.,
      47200., 19344., 20464., 21584., 22704., 23908., 25032., 26156., 27280.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6279.,  6414.,  6549.,  6684.,  7152.,  7296.,  7440.,  7584.,  7467.,
      7638.,  7809.,  7980.,  8484.,  8664.,  8844.,  9024.,  13407., 13758.,
      14109., 14460., 15144., 15504., 15864., 16224., 14595., 14982., 15369.,
      15756., 16476., 16872., 17268., 17664., 20535., 21102., 21669., 22236.,
      23136., 23712., 24288., 24864., 21723., 22326., 22929., 23532., 24468.,
      25080., 25692., 26304., 34791., 35790., 36789., 37788., 39120., 40128.,
      41136., 42144., 35979., 37014., 38049., 39084., 40452., 41496., 42540.,
      43584., 41919., 43134., 44349., 45564., 47112., 48336., 49560., 50784.,
      43107., 44358., 45609., 46860., 48444., 49704., 50964., 52224., 49047.,
      50478., 51909., 53340., 55104., 56544., 57984., 59424., 50235., 51702.,
      53169., 54636., 56436., 57912., 59388., 60864., 63303., 65166., 67029.,
      68892., 71088., 72960., 74832., 76704., 64491., 66390., 68289., 70188.,
      72420., 74328., 76236., 78144., 70431., 72510., 74589., 76668., 79080.,
      81168., 83256., 85344., 71619., 73734., 75849., 77964., 80412., 82536.,
      84660., 86784., 77559., 79854., 82149., 84444., 87072., 89376., 91680.,
      93984., 78747., 81078., 83409., 85740., 88404., 90744., 93084., 95424.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261.,  6684.,  7125.,  7584.,  7485.,  7980.,  8493.,  9024.,  5046.,
      5400.,  5766.,  6144.,  13605., 14460., 15333., 16224., 14829., 15756.,
      16701., 17664., 9366.,  10008., 10662., 11328., 20949., 22236., 23541.,
      24864., 22173., 23532., 24909., 26304., 13686., 14616., 15558., 16512.,
      11122., 12160., 13210., 14272., 11650., 12736., 13834., 14944., 6604.,
      7344.,  8092.,  8848.,  35637., 37788., 39957., 42144., 36861., 39084.,
      41325., 43584., 22326., 23832., 25350., 26880., 42981., 45564., 48165.,
      50784., 44205., 46860., 49533., 52224., 26646., 28440., 30246., 32064.,
      50325., 53340., 56373., 59424., 51549., 54636., 57741., 60864., 30966.,
      33048., 35142., 37248., 23794., 25984., 28186., 30400., 24322., 26560.,
      28810., 31072., 13516., 15024., 16540., 18064., 65013., 68892., 72789.,
      76704., 66237., 70188., 74157., 78144., 39606., 42264., 44934., 47616.,
      72357., 76668., 80997., 85344., 73581., 77964., 82365., 86784., 43926.,
      46872., 49830., 52800., 79701., 84444., 89205., 93984., 80925., 85740.,
      90573., 95424., 48246., 51480., 54726., 57984., 36466., 39808., 43162.,
      46528., 36994., 40384., 43786., 47200., 20428., 22704., 24988., 27280.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261.,  6684.,  7125.,  7584.,  7485.,  7980.,  8493.,  9024.,  13605.,
      14460., 15333., 16224., 14829., 15756., 16701., 17664., 20949., 22236.,
      23541., 24864., 22173., 23532., 24909., 26304., 35637., 37788., 39957.,
      42144., 36861., 39084., 41325., 43584., 42981., 45564., 48165., 50784.,
      44205., 46860., 49533., 52224., 50325., 53340., 56373., 59424., 51549.,
      54636., 57741., 60864., 65013., 68892., 72789., 76704., 66237., 70188.,
      74157., 78144., 72357., 76668., 80997., 85344., 73581., 77964., 82365.,
      86784., 79701., 84444., 89205., 93984., 80925., 85740., 90573., 95424.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261.,  12522.,  13098.,  13368.,  13971.,  14250.,  14880.,  15168.,
      14637.,  14970.,  15618.,  15960.,  16635.,  16986.,  17688.,  18048.,
      9834.,   10092.,  10536.,  10800.,  11262.,  11532.,  12012.,  12288.,
      26517.,  27210.,  28218.,  28920.,  29955.,  30666.,  31728.,  32448.,
      28893.,  29658.,  30738.,  31512.,  32619.,  33402.,  34536.,  35328.,
      18186.,  18732.,  19464.,  20016.,  20766.,  21324.,  22092.,  22656.,
      40773.,  41898.,  43338.,  44472.,  45939.,  47082.,  48576.,  49728.,
      43149.,  44346.,  45858.,  47064.,  48603.,  49818.,  51384.,  52608.,
      26538.,  27372.,  28392.,  29232.,  30270.,  31116.,  32172.,  33024.,
      21278.,  22244.,  23348.,  24320.,  25442.,  26420.,  27560.,  28544.,
      22286.,  23300.,  24452.,  25472.,  26642.,  27668.,  28856.,  29888.,
      12508.,  13208.,  13984.,  14688.,  15476.,  16184.,  16984.,  17696.,
      69285.,  71274.,  73578.,  75576.,  77907.,  79914.,  82272.,  84288.,
      71661.,  73722.,  76098.,  78168.,  80571.,  82650.,  85080.,  87168.,
      43242.,  44652.,  46248.,  47664.,  49278.,  50700.,  52332.,  53760.,
      83541.,  85962.,  88698.,  91128.,  93891.,  96330.,  99120.,  101568.,
      85917.,  88410.,  91218.,  93720.,  96555.,  99066.,  101928., 104448.,
      51594.,  53292.,  55176.,  56880.,  58782.,  60492.,  62412.,  64128.,
      97797.,  100650., 103818., 106680., 109875., 112746., 115968., 118848.,
      100173., 103098., 106338., 109272., 112539., 115482., 118776., 121728.,
      59946.,  61932.,  64104.,  66096.,  68286.,  70284.,  72492.,  74496.,
      45470.,  47588.,  49844.,  51968.,  54242.,  56372.,  58664.,  60800.,
      46478.,  48644.,  50948.,  53120.,  55442.,  57620.,  59960.,  62144.,
      25564.,  27032.,  28576.,  30048.,  31604.,  33080.,  34648.,  36128.,
      126309., 130026., 134058., 137784., 141843., 145578., 149664., 153408.,
      128685., 132474., 136578., 140376., 144507., 148314., 152472., 156288.,
      76650.,  79212.,  81960.,  84528.,  87294.,  89868.,  92652.,  95232.,
      140565., 144714., 149178., 153336., 157827., 161994., 166512., 170688.,
      142941., 147162., 151698., 155928., 160491., 164730., 169320., 173568.,
      85002.,  87852.,  90888.,  93744.,  96798.,  99660.,  102732., 105600.,
      154821., 159402., 164298., 168888., 173811., 178410., 183360., 187968.,
      157197., 161850., 166818., 171480., 176475., 181146., 186168., 190848.,
      93354.,  96492.,  99816.,  102960., 106302., 109452., 112812., 115968.,
      69662.,  72932.,  76340.,  79616.,  83042.,  86324.,  89768.,  93056.,
      70670.,  73988.,  77444.,  80768.,  84242.,  87572.,  91064.,  94400.,
      38620.,  40856.,  43168.,  45408.,  47732.,  49976.,  52312.,  54560.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261.,  12522.,  13098.,  13368.,  13971.,  14250.,  14880.,  15168.,
      14637.,  14970.,  15618.,  15960.,  16635.,  16986.,  17688.,  18048.,
      26517.,  27210.,  28218.,  28920.,  29955.,  30666.,  31728.,  32448.,
      28893.,  29658.,  30738.,  31512.,  32619.,  33402.,  34536.,  35328.,
      40773.,  41898.,  43338.,  44472.,  45939.,  47082.,  48576.,  49728.,
      43149.,  44346.,  45858.,  47064.,  48603.,  49818.,  51384.,  52608.,
      69285.,  71274.,  73578.,  75576.,  77907.,  79914.,  82272.,  84288.,
      71661.,  73722.,  76098.,  78168.,  80571.,  82650.,  85080.,  87168.,
      83541.,  85962.,  88698.,  91128.,  93891.,  96330.,  99120.,  101568.,
      85917.,  88410.,  91218.,  93720.,  96555.,  99066.,  101928., 104448.,
      97797.,  100650., 103818., 106680., 109875., 112746., 115968., 118848.,
      100173., 103098., 106338., 109272., 112539., 115482., 118776., 121728.,
      126309., 130026., 134058., 137784., 141843., 145578., 149664., 153408.,
      128685., 132474., 136578., 140376., 144507., 148314., 152472., 156288.,
      140565., 144714., 149178., 153336., 157827., 161994., 166512., 170688.,
      142941., 147162., 151698., 155928., 160491., 164730., 169320., 173568.,
      154821., 159402., 164298., 168888., 173811., 178410., 183360., 187968.,
      157197., 161850., 166818., 171480., 176475., 181146., 186168., 190848.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24261.,  24522.,  24783.,  25044.,  25926.,  26196.,  26466.,  26736.,
      27663.,  27942.,  28221.,  28500.,  29472.,  29760.,  30048.,  30336.,
      28941.,  29274.,  29607.,  29940.,  30894.,  31236.,  31578.,  31920.,
      32919.,  33270.,  33621.,  33972.,  35016.,  35376.,  35736.,  36096.,
      19410.,  19668.,  19926.,  20184.,  20808.,  21072.,  21336.,  21600.,
      22254.,  22524.,  22794.,  23064.,  23748.,  24024.,  24300.,  24576.,
      52341.,  53034.,  53727.,  54420.,  55734.,  56436.,  57138.,  57840.,
      59199.,  59910.,  60621.,  61332.,  62736.,  63456.,  64176.,  64896.,
      57021.,  57786.,  58551.,  59316.,  60702.,  61476.,  62250.,  63024.,
      64455.,  65238.,  66021.,  66804.,  68280.,  69072.,  69864.,  70656.,
      35826.,  36372.,  36918.,  37464.,  38376.,  38928.,  39480.,  40032.,
      40974.,  41532.,  42090.,  42648.,  43620.,  44184.,  44748.,  45312.,
      80421.,  81546.,  82671.,  83796.,  85542.,  86676.,  87810.,  88944.,
      90735.,  91878.,  93021.,  94164.,  96000.,  97152.,  98304.,  99456.,
      85101.,  86298.,  87495.,  88692.,  90510.,  91716.,  92922.,  94128.,
      95991.,  97206.,  98421.,  99636.,  101544., 102768., 103992., 105216.,
      52242.,  53076.,  53910.,  54744.,  55944.,  56784.,  57624.,  58464.,
      59694.,  60540.,  61386.,  62232.,  63492.,  64344.,  65196.,  66048.,
      41590.,  42556.,  43522.,  44488.,  45724.,  46696.,  47668.,  48640.,
      49906.,  50884.,  51862.,  52840.,  54136.,  55120.,  56104.,  57088.,
      43558.,  44572.,  45586.,  46600.,  47884.,  48904.,  49924.,  50944.,
      52258.,  53284.,  54310.,  55336.,  56680.,  57712.,  58744.,  59776.,
      24316.,  25016.,  25716.,  26416.,  27264.,  27968.,  28672.,  29376.,
      30244.,  30952.,  31660.,  32368.,  33256.,  33968.,  34680.,  35392.,
      136581., 138570., 140559., 142548., 145158., 147156., 149154., 151152.,
      153807., 155814., 157821., 159828., 162528., 164544., 166560., 168576.,
      141261., 143322., 145383., 147444., 150126., 152196., 154266., 156336.,
      159063., 161142., 163221., 165300., 168072., 170160., 172248., 174336.,
      85074.,  86484.,  87894.,  89304.,  91080.,  92496.,  93912.,  95328.,
      97134.,  98556.,  99978.,  101400., 103236., 104664., 106092., 107520.,
      164661., 167082., 169503., 171924., 174966., 177396., 179826., 182256.,
      185343., 187782., 190221., 192660., 195792., 198240., 200688., 203136.,
      169341., 171834., 174327., 176820., 179934., 182436., 184938., 187440.,
      190599., 193110., 195621., 198132., 201336., 203856., 206376., 208896.,
      101490., 103188., 104886., 106584., 108648., 110352., 112056., 113760.,
      115854., 117564., 119274., 120984., 123108., 124824., 126540., 128256.,
      192741., 195594., 198447., 201300., 204774., 207636., 210498., 213360.,
      216879., 219750., 222621., 225492., 229056., 231936., 234816., 237696.,
      197421., 200346., 203271., 206196., 209742., 212676., 215610., 218544.,
      222135., 225078., 228021., 230964., 234600., 237552., 240504., 243456.,
      117906., 119892., 121878., 123864., 126216., 128208., 130200., 132192.,
      134574., 136572., 138570., 140568., 142980., 144984., 146988., 148992.,
      88822.,  90940.,  93058.,  95176.,  97564.,  99688.,  101812., 103936.,
      106354., 108484., 110614., 112744., 115192., 117328., 119464., 121600.,
      90790.,  92956.,  95122.,  97288.,  99724.,  101896., 104068., 106240.,
      108706., 110884., 113062., 115240., 117736., 119920., 122104., 124288.,
      49660.,  51128.,  52596.,  54064.,  55680.,  57152.,  58624.,  60096.,
      61732.,  63208.,  64684.,  66160.,  67816.,  69296.,  70776.,  72256.,
      248901., 252618., 256335., 260052., 264390., 268116., 271842., 275568.,
      279951., 283686., 287421., 291156., 295584., 299328., 303072., 306816.,
      253581., 257370., 261159., 264948., 269358., 273156., 276954., 280752.,
      285207., 289014., 292821., 296628., 301128., 304944., 308760., 312576.,
      150738., 153300., 155862., 158424., 161352., 163920., 166488., 169056.,
      172014., 174588., 177162., 179736., 182724., 185304., 187884., 190464.,
      276981., 281130., 285279., 289428., 294198., 298356., 302514., 306672.,
      311487., 315654., 319821., 323988., 328848., 333024., 337200., 341376.,
      281661., 285882., 290103., 294324., 299166., 303396., 307626., 311856.,
      316743., 320982., 325221., 329460., 334392., 338640., 342888., 347136.,
      167154., 170004., 172854., 175704., 178920., 181776., 184632., 187488.,
      190734., 193596., 196458., 199320., 202596., 205464., 208332., 211200.,
      305061., 309642., 314223., 318804., 324006., 328596., 333186., 337776.,
      343023., 347622., 352221., 356820., 362112., 366720., 371328., 375936.,
      309741., 314394., 319047., 323700., 328974., 333636., 338298., 342960.,
      348279., 352950., 357621., 362292., 367656., 372336., 377016., 381696.,
      183570., 186708., 189846., 192984., 196488., 199632., 202776., 205920.,
      209454., 212604., 215754., 218904., 222468., 225624., 228780., 231936.,
      136054., 139324., 142594., 145864., 149404., 152680., 155956., 159232.,
      162802., 166084., 169366., 172648., 176248., 179536., 182824., 186112.,
      138022., 141340., 144658., 147976., 151564., 154888., 158212., 161536.,
      165154., 168484., 171814., 175144., 178792., 182128., 185464., 188800.,
      75004.,  77240.,  79476.,  81712.,  84096.,  86336.,  88576.,  90816.,
      93220.,  95464.,  97708.,  99952.,  102376., 104624., 106872., 109120.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24261.,  24522.,  24783.,  25044.,  25926.,  26196.,  26466.,  26736.,
      27663.,  27942.,  28221.,  28500.,  29472.,  29760.,  30048.,  30336.,
      28941.,  29274.,  29607.,  29940.,  30894.,  31236.,  31578.,  31920.,
      32919.,  33270.,  33621.,  33972.,  35016.,  35376.,  35736.,  36096.,
      52341.,  53034.,  53727.,  54420.,  55734.,  56436.,  57138.,  57840.,
      59199.,  59910.,  60621.,  61332.,  62736.,  63456.,  64176.,  64896.,
      57021.,  57786.,  58551.,  59316.,  60702.,  61476.,  62250.,  63024.,
      64455.,  65238.,  66021.,  66804.,  68280.,  69072.,  69864.,  70656.,
      80421.,  81546.,  82671.,  83796.,  85542.,  86676.,  87810.,  88944.,
      90735.,  91878.,  93021.,  94164.,  96000.,  97152.,  98304.,  99456.,
      85101.,  86298.,  87495.,  88692.,  90510.,  91716.,  92922.,  94128.,
      95991.,  97206.,  98421.,  99636.,  101544., 102768., 103992., 105216.,
      136581., 138570., 140559., 142548., 145158., 147156., 149154., 151152.,
      153807., 155814., 157821., 159828., 162528., 164544., 166560., 168576.,
      141261., 143322., 145383., 147444., 150126., 152196., 154266., 156336.,
      159063., 161142., 163221., 165300., 168072., 170160., 172248., 174336.,
      164661., 167082., 169503., 171924., 174966., 177396., 179826., 182256.,
      185343., 187782., 190221., 192660., 195792., 198240., 200688., 203136.,
      169341., 171834., 174327., 176820., 179934., 182436., 184938., 187440.,
      190599., 193110., 195621., 198132., 201336., 203856., 206376., 208896.,
      192741., 195594., 198447., 201300., 204774., 207636., 210498., 213360.,
      216879., 219750., 222621., 225492., 229056., 231936., 234816., 237696.,
      197421., 200346., 203271., 206196., 209742., 212676., 215610., 218544.,
      222135., 225078., 228021., 230964., 234600., 237552., 240504., 243456.,
      248901., 252618., 256335., 260052., 264390., 268116., 271842., 275568.,
      279951., 283686., 287421., 291156., 295584., 299328., 303072., 306816.,
      253581., 257370., 261159., 264948., 269358., 273156., 276954., 280752.,
      285207., 289014., 292821., 296628., 301128., 304944., 308760., 312576.,
      276981., 281130., 285279., 289428., 294198., 298356., 302514., 306672.,
      311487., 315654., 319821., 323988., 328848., 333024., 337200., 341376.,
      281661., 285882., 290103., 294324., 299166., 303396., 307626., 311856.,
      316743., 320982., 325221., 329460., 334392., 338640., 342888., 347136.,
      305061., 309642., 314223., 318804., 324006., 328596., 333186., 337776.,
      343023., 347622., 352221., 356820., 362112., 366720., 371328., 375936.,
      309741., 314394., 319047., 323700., 328974., 333636., 338298., 342960.,
      348279., 352950., 357621., 362292., 367656., 372336., 377016., 381696.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  516.,  1320., 1410., 1500., 948.,  2040., 2130.,
      2220., 1380., 1174., 1216., 1258., 739.,  3480., 3570., 3660., 2244.,
      4200., 4290., 4380., 2676., 4920., 5010., 5100., 3108., 2518., 2560.,
      2602., 1507., 6360., 6450., 6540., 3972., 7080., 7170., 7260., 4404.,
      7800., 7890., 7980., 4836., 3862., 3904., 3946., 2275.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  1320., 1410., 1500., 2040., 2130., 2220.,
      3480., 3570., 3660., 4200., 4290., 4380., 4920., 5010., 5100.,
      6360., 6450., 6540., 7080., 7170., 7260., 7800., 7890., 7980.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110.,  1200.,  1272.,  1380.,  1434.,  1560.,  939.,   1032., 2406.,
      2640.,  2568.,  2820.,  2730.,  3000.,  1707.,  1896.,  3702., 4080.,
      3864.,  4260.,  4026.,  4440.,  2475.,  2760.,  2024.,  2348., 2096.,
      2432.,  2168.,  2516.,  1240.,  1478.,  6294.,  6960.,  6456., 7140.,
      6618.,  7320.,  4011.,  4488.,  7590.,  8400.,  7752.,  8580., 7914.,
      8760.,  4779.,  5352.,  8886.,  9840.,  9048.,  10020., 9210., 10200.,
      5547.,  6216.,  4328.,  5036.,  4400.,  5120.,  4472.,  5204., 2520.,
      3014.,  11478., 12720., 11640., 12900., 11802., 13080., 7083., 7944.,
      12774., 14160., 12936., 14340., 13098., 14520., 7851.,  8808., 14070.,
      15600., 14232., 15780., 14394., 15960., 8619.,  9672.,  6632., 7724.,
      6704.,  7808.,  6776.,  7892.,  3800.,  4550.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110.,  1200.,  1272.,  1380.,  1434.,  1560.,  2406.,  2640.,  2568.,
      2820.,  2730.,  3000.,  3702.,  4080.,  3864.,  4260.,  4026.,  4440.,
      6294.,  6960.,  6456.,  7140.,  6618.,  7320.,  7590.,  8400.,  7752.,
      8580.,  7914.,  8760.,  8886.,  9840.,  9048.,  10020., 9210.,  10200.,
      11478., 12720., 11640., 12900., 11802., 13080., 12774., 14160., 12936.,
      14340., 13098., 14520., 14070., 15600., 14232., 15780., 14394., 15960.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130.,  2220.,  2310.,  2400.,  2436.,  2544.,  2652.,  2760.,  2742.,
      2868.,  2994.,  3120.,  1785.,  1878.,  1971.,  2064.,  4578.,  4812.,
      5046.,  5280.,  4884.,  5136.,  5388.,  5640.,  5190.,  5460.,  5730.,
      6000.,  3225.,  3414.,  3603.,  3792.,  7026.,  7404.,  7782.,  8160.,
      7332.,  7728.,  8124.,  8520.,  7638.,  8052.,  8466.,  8880.,  4665.,
      4950.,  5235.,  5520.,  3724.,  4048.,  4372.,  4696.,  3856.,  4192.,
      4528.,  4864.,  3988.,  4336.,  4684.,  5032.,  2242.,  2480.,  2718.,
      2956.,  11922., 12588., 13254., 13920., 12228., 12912., 13596., 14280.,
      12534., 13236., 13938., 14640., 7545.,  8022.,  8499.,  8976.,  14370.,
      15180., 15990., 16800., 14676., 15504., 16332., 17160., 14982., 15828.,
      16674., 17520., 8985.,  9558.,  10131., 10704., 16818., 17772., 18726.,
      19680., 17124., 18096., 19068., 20040., 17430., 18420., 19410., 20400.,
      10425., 11094., 11763., 12432., 7948.,  8656.,  9364.,  10072., 8080.,
      8800.,  9520.,  10240., 8212.,  8944.,  9676.,  10408., 4546.,  5040.,
      5534.,  6028.,  21714., 22956., 24198., 25440., 22020., 23280., 24540.,
      25800., 22326., 23604., 24882., 26160., 13305., 14166., 15027., 15888.,
      24162., 25548., 26934., 28320., 24468., 25872., 27276., 28680., 24774.,
      26196., 27618., 29040., 14745., 15702., 16659., 17616., 26610., 28140.,
      29670., 31200., 26916., 28464., 30012., 31560., 27222., 28788., 30354.,
      31920., 16185., 17238., 18291., 19344., 12172., 13264., 14356., 15448.,
      12304., 13408., 14512., 15616., 12436., 13552., 14668., 15784., 6850.,
      7600.,  8350.,  9100.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130.,  2220.,  2310.,  2400.,  2436.,  2544.,  2652.,  2760.,  2742.,
      2868.,  2994.,  3120.,  4578.,  4812.,  5046.,  5280.,  4884.,  5136.,
      5388.,  5640.,  5190.,  5460.,  5730.,  6000.,  7026.,  7404.,  7782.,
      8160.,  7332.,  7728.,  8124.,  8520.,  7638.,  8052.,  8466.,  8880.,
      11922., 12588., 13254., 13920., 12228., 12912., 13596., 14280., 12534.,
      13236., 13938., 14640., 14370., 15180., 15990., 16800., 14676., 15504.,
      16332., 17160., 14982., 15828., 16674., 17520., 16818., 17772., 18726.,
      19680., 17124., 18096., 19068., 20040., 17430., 18420., 19410., 20400.,
      21714., 22956., 24198., 25440., 22020., 23280., 24540., 25800., 22326.,
      23604., 24882., 26160., 24162., 25548., 26934., 28320., 24468., 25872.,
      27276., 28680., 24774., 26196., 27618., 29040., 26610., 28140., 29670.,
      31200., 26916., 28464., 30012., 31560., 27222., 28788., 30354., 31920.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2139.,  2400.,  2463.,  2760.,  2787.,  3120.,  1830.,  2064.,  4731.,
      5280.,  5055.,  5640.,  5379.,  6000.,  3366.,  3792.,  7323.,  8160.,
      7647.,  8520.,  7971.,  8880.,  4902.,  5520.,  4012.,  4696.,  4156.,
      4864.,  4300.,  5032.,  2460.,  2956.,  12507., 13920., 12831., 14280.,
      13155., 14640., 7974.,  8976.,  15099., 16800., 15423., 17160., 15747.,
      17520., 9510.,  10704., 17691., 19680., 18015., 20040., 18339., 20400.,
      11046., 12432., 8620.,  10072., 8764.,  10240., 8908.,  10408., 5020.,
      6028.,  22875., 25440., 23199., 25800., 23523., 26160., 14118., 15888.,
      25467., 28320., 25791., 28680., 26115., 29040., 15654., 17616., 28059.,
      31200., 28383., 31560., 28707., 31920., 17190., 19344., 13228., 15448.,
      13372., 15616., 13516., 15784., 7580.,  9100.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2139.,  2400.,  2463.,  2760.,  2787.,  3120.,  4731.,  5280.,  5055.,
      5640.,  5379.,  6000.,  7323.,  8160.,  7647.,  8520.,  7971.,  8880.,
      12507., 13920., 12831., 14280., 13155., 14640., 15099., 16800., 15423.,
      17160., 15747., 17520., 17691., 19680., 18015., 20040., 18339., 20400.,
      22875., 25440., 23199., 25800., 23523., 26160., 25467., 28320., 25791.,
      28680., 26115., 29040., 28059., 31200., 28383., 31560., 28707., 31920.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107.,  4278.,  4620.,  4800.,  4719.,  4926.,  5304.,  5520.,  5331.,
      5574.,  5988.,  6240.,  3480.,  3660.,  3942.,  4128.,  9003.,  9462.,
      10092., 10560., 9615.,  10110., 10776., 11280., 10227., 10758., 11460.,
      12000., 6360.,  6732.,  7206.,  7584.,  13899., 14646., 15564., 16320.,
      14511., 15294., 16248., 17040., 15123., 15942., 16932., 17760., 9240.,
      9804.,  10470., 11040., 7382.,  8024.,  8744.,  9392.,  7646.,  8312.,
      9056.,  9728.,  7910.,  8600.,  9368.,  10064., 4448.,  4920.,  5436.,
      5912.,  23691., 25014., 26508., 27840., 24303., 25662., 27192., 28560.,
      24915., 26310., 27876., 29280., 15000., 15948., 16998., 17952., 28587.,
      30198., 31980., 33600., 29199., 30846., 32664., 34320., 29811., 31494.,
      33348., 35040., 17880., 19020., 20262., 21408., 33483., 35382., 37452.,
      39360., 34095., 36030., 38136., 40080., 34707., 36678., 38820., 40800.,
      20760., 22092., 23526., 24864., 15830., 17240., 18728., 20144., 16094.,
      17528., 19040., 20480., 16358., 17816., 19352., 20816., 9056.,  10040.,
      11068., 12056., 43275., 45750., 48396., 50880., 43887., 46398., 49080.,
      51600., 44499., 47046., 49764., 52320., 26520., 28236., 30054., 31776.,
      48171., 50934., 53868., 56640., 48783., 51582., 54552., 57360., 49395.,
      52230., 55236., 58080., 29400., 31308., 33318., 35232., 53067., 56118.,
      59340., 62400., 53679., 56766., 60024., 63120., 54291., 57414., 60708.,
      63840., 32280., 34380., 36582., 38688., 24278., 26456., 28712., 30896.,
      24542., 26744., 29024., 31232., 24806., 27032., 29336., 31568., 13664.,
      15160., 16700., 18200.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107.,  4278.,  4620.,  4800.,  4719.,  4926.,  5304.,  5520.,  5331.,
      5574.,  5988.,  6240.,  9003.,  9462.,  10092., 10560., 9615.,  10110.,
      10776., 11280., 10227., 10758., 11460., 12000., 13899., 14646., 15564.,
      16320., 14511., 15294., 16248., 17040., 15123., 15942., 16932., 17760.,
      23691., 25014., 26508., 27840., 24303., 25662., 27192., 28560., 24915.,
      26310., 27876., 29280., 28587., 30198., 31980., 33600., 29199., 30846.,
      32664., 34320., 29811., 31494., 33348., 35040., 33483., 35382., 37452.,
      39360., 34095., 36030., 38136., 40080., 34707., 36678., 38820., 40800.,
      43275., 45750., 48396., 50880., 43887., 46398., 49080., 51600., 44499.,
      47046., 49764., 52320., 48171., 50934., 53868., 56640., 48783., 51582.,
      54552., 57360., 49395., 52230., 55236., 58080., 53067., 56118., 59340.,
      62400., 53679., 56766., 60024., 63120., 54291., 57414., 60708., 63840.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8043.,   8214.,   8385.,   8556.,   9060.,   9240.,   9420.,   9600.,
      9231.,   9438.,   9645.,   9852.,   10392.,  10608.,  10824.,  11040.,
      10419.,  10662.,  10905.,  11148.,  11724.,  11976.,  12228.,  12480.,
      6780.,   6960.,   7140.,   7320.,   7698.,   7884.,   8070.,   8256.,
      17547.,  18006.,  18465.,  18924.,  19716.,  20184.,  20652.,  21120.,
      18735.,  19230.,  19725.,  20220.,  21048.,  21552.,  22056.,  22560.,
      19923.,  20454.,  20985.,  21516.,  22380.,  22920.,  23460.,  24000.,
      12348.,  12720.,  13092.,  13464.,  14034.,  14412.,  14790.,  15168.,
      27051.,  27798.,  28545.,  29292.,  30372.,  31128.,  31884.,  32640.,
      28239.,  29022.,  29805.,  30588.,  31704.,  32496.,  33288.,  34080.,
      29427.,  30246.,  31065.,  31884.,  33036.,  33864.,  34692.,  35520.,
      17916.,  18480.,  19044.,  19608.,  20370.,  20940.,  21510.,  22080.,
      14122.,  14764.,  15406.,  16048.,  16840.,  17488.,  18136.,  18784.,
      14626.,  15292.,  15958.,  16624.,  17440.,  18112.,  18784.,  19456.,
      15130.,  15820.,  16510.,  17200.,  18040.,  18736.,  19432.,  20128.,
      8424.,   8896.,   9368.,   9840.,   10396.,  10872.,  11348.,  11824.,
      46059.,  47382.,  48705.,  50028.,  51684.,  53016.,  54348.,  55680.,
      47247.,  48606.,  49965.,  51324.,  53016.,  54384.,  55752.,  57120.,
      48435.,  49830.,  51225.,  52620.,  54348.,  55752.,  57156.,  58560.,
      29052.,  30000.,  30948.,  31896.,  33042.,  33996.,  34950.,  35904.,
      55563.,  57174.,  58785.,  60396.,  62340.,  63960.,  65580.,  67200.,
      56751.,  58398.,  60045.,  61692.,  63672.,  65328.,  66984.,  68640.,
      57939.,  59622.,  61305.,  62988.,  65004.,  66696.,  68388.,  70080.,
      34620.,  35760.,  36900.,  38040.,  39378.,  40524.,  41670.,  42816.,
      65067.,  66966.,  68865.,  70764.,  72996.,  74904.,  76812.,  78720.,
      66255.,  68190.,  70125.,  72060.,  74328.,  76272.,  78216.,  80160.,
      67443.,  69414.,  71385.,  73356.,  75660.,  77640.,  79620.,  81600.,
      40188.,  41520.,  42852.,  44184.,  45714.,  47052.,  48390.,  49728.,
      30250.,  31660.,  33070.,  34480.,  36040.,  37456.,  38872.,  40288.,
      30754.,  32188.,  33622.,  35056.,  36640.,  38080.,  39520.,  40960.,
      31258.,  32716.,  34174.,  35632.,  37240.,  38704.,  40168.,  41632.,
      17128.,  18112.,  19096.,  20080.,  21148.,  22136.,  23124.,  24112.,
      84075.,  86550.,  89025.,  91500.,  94308.,  96792.,  99276.,  101760.,
      85263.,  87774.,  90285.,  92796.,  95640.,  98160.,  100680., 103200.,
      86451.,  88998.,  91545.,  94092.,  96972.,  99528.,  102084., 104640.,
      51324.,  53040.,  54756.,  56472.,  58386.,  60108.,  61830.,  63552.,
      93579.,  96342.,  99105.,  101868., 104964., 107736., 110508., 113280.,
      94767.,  97566.,  100365., 103164., 106296., 109104., 111912., 114720.,
      95955.,  98790.,  101625., 104460., 107628., 110472., 113316., 116160.,
      56892.,  58800.,  60708.,  62616.,  64722.,  66636.,  68550.,  70464.,
      103083., 106134., 109185., 112236., 115620., 118680., 121740., 124800.,
      104271., 107358., 110445., 113532., 116952., 120048., 123144., 126240.,
      105459., 108582., 111705., 114828., 118284., 121416., 124548., 127680.,
      62460.,  64560.,  66660.,  68760.,  71058.,  73164.,  75270.,  77376.,
      46378.,  48556.,  50734.,  52912.,  55240.,  57424.,  59608.,  61792.,
      46882.,  49084.,  51286.,  53488.,  55840.,  58048.,  60256.,  62464.,
      47386.,  49612.,  51838.,  54064.,  56440.,  58672.,  60904.,  63136.,
      25832.,  27328.,  28824.,  30320.,  31900.,  33400.,  34900.,  36400.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8043.,   8214.,   8385.,   8556.,   9060.,   9240.,   9420.,   9600.,
      9231.,   9438.,   9645.,   9852.,   10392.,  10608.,  10824.,  11040.,
      10419.,  10662.,  10905.,  11148.,  11724.,  11976.,  12228.,  12480.,
      17547.,  18006.,  18465.,  18924.,  19716.,  20184.,  20652.,  21120.,
      18735.,  19230.,  19725.,  20220.,  21048.,  21552.,  22056.,  22560.,
      19923.,  20454.,  20985.,  21516.,  22380.,  22920.,  23460.,  24000.,
      27051.,  27798.,  28545.,  29292.,  30372.,  31128.,  31884.,  32640.,
      28239.,  29022.,  29805.,  30588.,  31704.,  32496.,  33288.,  34080.,
      29427.,  30246.,  31065.,  31884.,  33036.,  33864.,  34692.,  35520.,
      46059.,  47382.,  48705.,  50028.,  51684.,  53016.,  54348.,  55680.,
      47247.,  48606.,  49965.,  51324.,  53016.,  54384.,  55752.,  57120.,
      48435.,  49830.,  51225.,  52620.,  54348.,  55752.,  57156.,  58560.,
      55563.,  57174.,  58785.,  60396.,  62340.,  63960.,  65580.,  67200.,
      56751.,  58398.,  60045.,  61692.,  63672.,  65328.,  66984.,  68640.,
      57939.,  59622.,  61305.,  62988.,  65004.,  66696.,  68388.,  70080.,
      65067.,  66966.,  68865.,  70764.,  72996.,  74904.,  76812.,  78720.,
      66255.,  68190.,  70125.,  72060.,  74328.,  76272.,  78216.,  80160.,
      67443.,  69414.,  71385.,  73356.,  75660.,  77640.,  79620.,  81600.,
      84075.,  86550.,  89025.,  91500.,  94308.,  96792.,  99276.,  101760.,
      85263.,  87774.,  90285.,  92796.,  95640.,  98160.,  100680., 103200.,
      86451.,  88998.,  91545.,  94092.,  96972.,  99528.,  102084., 104640.,
      93579.,  96342.,  99105.,  101868., 104964., 107736., 110508., 113280.,
      94767.,  97566.,  100365., 103164., 106296., 109104., 111912., 114720.,
      95955.,  98790.,  101625., 104460., 107628., 110472., 113316., 116160.,
      103083., 106134., 109185., 112236., 115620., 118680., 121740., 124800.,
      104271., 107358., 110445., 113532., 116952., 120048., 123144., 126240.,
      105459., 108582., 111705., 114828., 118284., 121416., 124548., 127680.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,   8556.,   9069.,   9600.,   9285.,   9852.,   10437.,  11040.,
      10509.,  11148.,  11805.,  12480.,  6870.,   7320.,   7782.,   8256.,
      17853.,  18924.,  20013.,  21120.,  19077.,  20220.,  21381.,  22560.,
      20301.,  21516.,  22749.,  24000.,  12630.,  13464.,  14310.,  15168.,
      27645.,  29292.,  30957.,  32640.,  28869.,  30588.,  32325.,  34080.,
      30093.,  31884.,  33693.,  35520.,  18390.,  19608.,  20838.,  22080.,
      14698.,  16048.,  17410.,  18784.,  15226.,  16624.,  18034.,  19456.,
      15754.,  17200.,  18658.,  20128.,  8860.,   9840.,   10828.,  11824.,
      47229.,  50028.,  52845.,  55680.,  48453.,  51324.,  54213.,  57120.,
      49677.,  52620.,  55581.,  58560.,  29910.,  31896.,  33894.,  35904.,
      57021.,  60396.,  63789.,  67200.,  58245.,  61692.,  65157.,  68640.,
      59469.,  62988.,  66525.,  70080.,  35670.,  38040.,  40422.,  42816.,
      66813.,  70764.,  74733.,  78720.,  68037.,  72060.,  76101.,  80160.,
      69261.,  73356.,  77469.,  81600.,  41430.,  44184.,  46950.,  49728.,
      31594.,  34480.,  37378.,  40288.,  32122.,  35056.,  38002.,  40960.,
      32650.,  35632.,  38626.,  41632.,  18076.,  20080.,  22092.,  24112.,
      86397.,  91500.,  96621.,  101760., 87621.,  92796.,  97989.,  103200.,
      88845.,  94092.,  99357.,  104640., 52950.,  56472.,  60006.,  63552.,
      96189.,  101868., 107565., 113280., 97413.,  103164., 108933., 114720.,
      98637.,  104460., 110301., 116160., 58710.,  62616.,  66534.,  70464.,
      105981., 112236., 118509., 124800., 107205., 113532., 119877., 126240.,
      108429., 114828., 121245., 127680., 64470.,  68760.,  73062.,  77376.,
      48490.,  52912.,  57346.,  61792.,  49018.,  53488.,  57970.,  62464.,
      49546.,  54064.,  58594.,  63136.,  27292.,  30320.,  33356.,  36400.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,   8556.,   9069.,   9600.,   9285.,   9852.,   10437.,  11040.,
      10509.,  11148.,  11805.,  12480.,  17853.,  18924.,  20013.,  21120.,
      19077.,  20220.,  21381.,  22560.,  20301.,  21516.,  22749.,  24000.,
      27645.,  29292.,  30957.,  32640.,  28869.,  30588.,  32325.,  34080.,
      30093.,  31884.,  33693.,  35520.,  47229.,  50028.,  52845.,  55680.,
      48453.,  51324.,  54213.,  57120.,  49677.,  52620.,  55581.,  58560.,
      57021.,  60396.,  63789.,  67200.,  58245.,  61692.,  65157.,  68640.,
      59469.,  62988.,  66525.,  70080.,  66813.,  70764.,  74733.,  78720.,
      68037.,  72060.,  76101.,  80160.,  69261.,  73356.,  77469.,  81600.,
      86397.,  91500.,  96621.,  101760., 87621.,  92796.,  97989.,  103200.,
      88845.,  94092.,  99357.,  104640., 96189.,  101868., 107565., 113280.,
      97413.,  103164., 108933., 114720., 98637.,  104460., 110301., 116160.,
      105981., 112236., 118509., 124800., 107205., 113532., 119877., 126240.,
      108429., 114828., 121245., 127680.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789.,  16122.,  16770.,  17112.,  17787.,  18138.,  18840.,  19200.,
      18165.,  18570.,  19290.,  19704.,  20451.,  20874.,  21648.,  22080.,
      20541.,  21018.,  21810.,  22296.,  23115.,  23610.,  24456.,  24960.,
      13386.,  13740.,  14280.,  14640.,  15198.,  15564.,  16140.,  16512.,
      34797.,  35706.,  36930.,  37848.,  39099.,  40026.,  41304.,  42240.,
      37173.,  38154.,  39450.,  40440.,  41763.,  42762.,  44112.,  45120.,
      39549.,  40602.,  41970.,  43032.,  44427.,  45498.,  46920.,  48000.,
      24522.,  25260.,  26184.,  26928.,  27870.,  28620.,  29580.,  30336.,
      53805.,  55290.,  57090.,  58584.,  60411.,  61914.,  63768.,  65280.,
      56181.,  57738.,  59610.,  61176.,  63075.,  64650.,  66576.,  68160.,
      58557.,  60186.,  62130.,  63768.,  65739.,  67386.,  69384.,  71040.,
      35658.,  36780.,  38088.,  39216.,  40542.,  41676.,  43020.,  44160.,
      28118.,  29396.,  30812.,  32096.,  33530.,  34820.,  36272.,  37568.,
      29126.,  30452.,  31916.,  33248.,  34730.,  36068.,  37568.,  38912.,
      30134.,  31508.,  33020.,  34400.,  35930.,  37316.,  38864.,  40256.,
      16780.,  17720.,  18736.,  19680.,  20708.,  21656.,  22696.,  23648.,
      91821.,  94458.,  97410.,  100056., 103035., 105690., 108696., 111360.,
      94197.,  96906.,  99930.,  102648., 105699., 108426., 111504., 114240.,
      96573.,  99354.,  102450., 105240., 108363., 111162., 114312., 117120.,
      57930.,  59820.,  61896.,  63792.,  65886.,  67788.,  69900.,  71808.,
      110829., 114042., 117570., 120792., 124347., 127578., 131160., 134400.,
      113205., 116490., 120090., 123384., 127011., 130314., 133968., 137280.,
      115581., 118938., 122610., 125976., 129675., 133050., 136776., 140160.,
      69066.,  71340.,  73800.,  76080.,  78558.,  80844.,  83340.,  85632.,
      129837., 133626., 137730., 141528., 145659., 149466., 153624., 157440.,
      132213., 136074., 140250., 144120., 148323., 152202., 156432., 160320.,
      134589., 138522., 142770., 146712., 150987., 154938., 159240., 163200.,
      80202.,  82860.,  85704.,  88368.,  91230.,  93900.,  96780.,  99456.,
      60374.,  63188.,  66140.,  68960.,  71930.,  74756.,  77744.,  80576.,
      61382.,  64244.,  67244.,  70112.,  73130.,  76004.,  79040.,  81920.,
      62390.,  65300.,  68348.,  71264.,  74330.,  77252.,  80336.,  83264.,
      34188.,  36152.,  38192.,  40160.,  42212.,  44184.,  46248.,  48224.,
      167853., 172794., 178050., 183000., 188283., 193242., 198552., 203520.,
      170229., 175242., 180570., 185592., 190947., 195978., 201360., 206400.,
      172605., 177690., 183090., 188184., 193611., 198714., 204168., 209280.,
      102474., 105900., 109512., 112944., 116574., 120012., 123660., 127104.,
      186861., 192378., 198210., 203736., 209595., 215130., 221016., 226560.,
      189237., 194826., 200730., 206328., 212259., 217866., 223824., 229440.,
      191613., 197274., 203250., 208920., 214923., 220602., 226632., 232320.,
      113610., 117420., 121416., 125232., 129246., 133068., 137100., 140928.,
      205869., 211962., 218370., 224472., 230907., 237018., 243480., 249600.,
      208245., 214410., 220890., 227064., 233571., 239754., 246288., 252480.,
      210621., 216858., 223410., 229656., 236235., 242490., 249096., 255360.,
      124746., 128940., 133320., 137520., 141918., 146124., 150540., 154752.,
      92630.,  96980.,  101468., 105824., 110330., 114692., 119216., 123584.,
      93638.,  98036.,  102572., 106976., 111530., 115940., 120512., 124928.,
      94646.,  99092.,  103676., 108128., 112730., 117188., 121808., 126272.,
      51596.,  54584.,  57648.,  60640.,  63716.,  66712.,  69800.,  72800.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789.,  16122.,  16770.,  17112.,  17787.,  18138.,  18840.,  19200.,
      18165.,  18570.,  19290.,  19704.,  20451.,  20874.,  21648.,  22080.,
      20541.,  21018.,  21810.,  22296.,  23115.,  23610.,  24456.,  24960.,
      34797.,  35706.,  36930.,  37848.,  39099.,  40026.,  41304.,  42240.,
      37173.,  38154.,  39450.,  40440.,  41763.,  42762.,  44112.,  45120.,
      39549.,  40602.,  41970.,  43032.,  44427.,  45498.,  46920.,  48000.,
      53805.,  55290.,  57090.,  58584.,  60411.,  61914.,  63768.,  65280.,
      56181.,  57738.,  59610.,  61176.,  63075.,  64650.,  66576.,  68160.,
      58557.,  60186.,  62130.,  63768.,  65739.,  67386.,  69384.,  71040.,
      91821.,  94458.,  97410.,  100056., 103035., 105690., 108696., 111360.,
      94197.,  96906.,  99930.,  102648., 105699., 108426., 111504., 114240.,
      96573.,  99354.,  102450., 105240., 108363., 111162., 114312., 117120.,
      110829., 114042., 117570., 120792., 124347., 127578., 131160., 134400.,
      113205., 116490., 120090., 123384., 127011., 130314., 133968., 137280.,
      115581., 118938., 122610., 125976., 129675., 133050., 136776., 140160.,
      129837., 133626., 137730., 141528., 145659., 149466., 153624., 157440.,
      132213., 136074., 140250., 144120., 148323., 152202., 156432., 160320.,
      134589., 138522., 142770., 146712., 150987., 154938., 159240., 163200.,
      167853., 172794., 178050., 183000., 188283., 193242., 198552., 203520.,
      170229., 175242., 180570., 185592., 190947., 195978., 201360., 206400.,
      172605., 177690., 183090., 188184., 193611., 198714., 204168., 209280.,
      186861., 192378., 198210., 203736., 209595., 215130., 221016., 226560.,
      189237., 194826., 200730., 206328., 212259., 217866., 223824., 229440.,
      191613., 197274., 203250., 208920., 214923., 220602., 226632., 232320.,
      205869., 211962., 218370., 224472., 230907., 237018., 243480., 249600.,
      208245., 214410., 220890., 227064., 233571., 239754., 246288., 252480.,
      210621., 216858., 223410., 229656., 236235., 242490., 249096., 255360.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31245.,  31578.,  31911.,  32244.,  33198.,  33540.,  33882.,  34224.,
      35223.,  35574.,  35925.,  36276.,  37320.,  37680.,  38040.,  38400.,
      35925.,  36330.,  36735.,  37140.,  38166.,  38580.,  38994.,  39408.,
      40479.,  40902.,  41325.,  41748.,  42864.,  43296.,  43728.,  44160.,
      40605.,  41082.,  41559.,  42036.,  43134.,  43620.,  44106.,  44592.,
      45735.,  46230.,  46725.,  47220.,  48408.,  48912.,  49416.,  49920.,
      26418.,  26772.,  27126.,  27480.,  28200.,  28560.,  28920.,  29280.,
      30030.,  30396.,  30762.,  31128.,  31908.,  32280.,  32652.,  33024.,
      68685.,  69594.,  70503.,  71412.,  72942.,  73860.,  74778.,  75696.,
      77271.,  78198.,  79125.,  80052.,  81672.,  82608.,  83544.,  84480.,
      73365.,  74346.,  75327.,  76308.,  77910.,  78900.,  79890.,  80880.,
      82527.,  83526.,  84525.,  85524.,  87216.,  88224.,  89232.,  90240.,
      78045.,  79098.,  80151.,  81204.,  82878.,  83940.,  85002.,  86064.,
      87783.,  88854.,  89925.,  90996.,  92760.,  93840.,  94920.,  96000.,
      48306.,  49044.,  49782.,  50520.,  51624.,  52368.,  53112.,  53856.,
      54990.,  55740.,  56490.,  57240.,  58404.,  59160.,  59916.,  60672.,
      106125., 107610., 109095., 110580., 112686., 114180., 115674., 117168.,
      119319., 120822., 122325., 123828., 126024., 127536., 129048., 130560.,
      110805., 112362., 113919., 115476., 117654., 119220., 120786., 122352.,
      124575., 126150., 127725., 129300., 131568., 133152., 134736., 136320.,
      115485., 117114., 118743., 120372., 122622., 124260., 125898., 127536.,
      129831., 131478., 133125., 134772., 137112., 138768., 140424., 142080.,
      70194.,  71316.,  72438.,  73560.,  75048.,  76176.,  77304.,  78432.,
      79950.,  81084.,  82218.,  83352.,  84900.,  86040.,  87180.,  88320.,
      54958.,  56236.,  57514.,  58792.,  60340.,  61624.,  62908.,  64192.,
      65770.,  67060.,  68350.,  69640.,  71248.,  72544.,  73840.,  75136.,
      56926.,  58252.,  59578.,  60904.,  62500.,  63832.,  65164.,  66496.,
      68122.,  69460.,  70798.,  72136.,  73792.,  75136.,  76480.,  77824.,
      58894.,  60268.,  61642.,  63016.,  64660.,  66040.,  67420.,  68800.,
      70474.,  71860.,  73246.,  74632.,  76336.,  77728.,  79120.,  80512.,
      32620.,  33560.,  34500.,  35440.,  36528.,  37472.,  38416.,  39360.,
      40468.,  41416.,  42364.,  43312.,  44440.,  45392.,  46344.,  47296.,
      181005., 183642., 186279., 188916., 192174., 194820., 197466., 200112.,
      203415., 206070., 208725., 211380., 214728., 217392., 220056., 222720.,
      185685., 188394., 191103., 193812., 197142., 199860., 202578., 205296.,
      208671., 211398., 214125., 216852., 220272., 223008., 225744., 228480.,
      190365., 193146., 195927., 198708., 202110., 204900., 207690., 210480.,
      213927., 216726., 219525., 222324., 225816., 228624., 231432., 234240.,
      113970., 115860., 117750., 119640., 121896., 123792., 125688., 127584.,
      129870., 131772., 133674., 135576., 137892., 139800., 141708., 143616.,
      218445., 221658., 224871., 228084., 231918., 235140., 238362., 241584.,
      245463., 248694., 251925., 255156., 259080., 262320., 265560., 268800.,
      223125., 226410., 229695., 232980., 236886., 240180., 243474., 246768.,
      250719., 254022., 257325., 260628., 264624., 267936., 271248., 274560.,
      227805., 231162., 234519., 237876., 241854., 245220., 248586., 251952.,
      255975., 259350., 262725., 266100., 270168., 273552., 276936., 280320.,
      135858., 138132., 140406., 142680., 145320., 147600., 149880., 152160.,
      154830., 157116., 159402., 161688., 164388., 166680., 168972., 171264.,
      255885., 259674., 263463., 267252., 271662., 275460., 279258., 283056.,
      287511., 291318., 295125., 298932., 303432., 307248., 311064., 314880.,
      260565., 264426., 268287., 272148., 276630., 280500., 284370., 288240.,
      292767., 296646., 300525., 304404., 308976., 312864., 316752., 320640.,
      265245., 269178., 273111., 277044., 281598., 285540., 289482., 293424.,
      298023., 301974., 305925., 309876., 314520., 318480., 322440., 326400.,
      157746., 160404., 163062., 165720., 168744., 171408., 174072., 176736.,
      179790., 182460., 185130., 187800., 190884., 193560., 196236., 198912.,
      117934., 120748., 123562., 126376., 129460., 132280., 135100., 137920.,
      141034., 143860., 146686., 149512., 152656., 155488., 158320., 161152.,
      119902., 122764., 125626., 128488., 131620., 134488., 137356., 140224.,
      143386., 146260., 149134., 152008., 155200., 158080., 160960., 163840.,
      121870., 124780., 127690., 130600., 133780., 136696., 139612., 142528.,
      145738., 148660., 151582., 154504., 157744., 160672., 163600., 166528.,
      66412.,  68376.,  70340.,  72304.,  74416.,  76384.,  78352.,  80320.,
      82452.,  84424.,  86396.,  88368.,  90520.,  92496.,  94472.,  96448.,
      330765., 335706., 340647., 345588., 351150., 356100., 361050., 366000.,
      371607., 376566., 381525., 386484., 392136., 397104., 402072., 407040.,
      335445., 340458., 345471., 350484., 356118., 361140., 366162., 371184.,
      376863., 381894., 386925., 391956., 397680., 402720., 407760., 412800.,
      340125., 345210., 350295., 355380., 361086., 366180., 371274., 376368.,
      382119., 387222., 392325., 397428., 403224., 408336., 413448., 418560.,
      201522., 204948., 208374., 211800., 215592., 219024., 222456., 225888.,
      229710., 233148., 236586., 240024., 243876., 247320., 250764., 254208.,
      368205., 373722., 379239., 384756., 390894., 396420., 401946., 407472.,
      413655., 419190., 424725., 430260., 436488., 442032., 447576., 453120.,
      372885., 378474., 384063., 389652., 395862., 401460., 407058., 412656.,
      418911., 424518., 430125., 435732., 442032., 447648., 453264., 458880.,
      377565., 383226., 388887., 394548., 400830., 406500., 412170., 417840.,
      424167., 429846., 435525., 441204., 447576., 453264., 458952., 464640.,
      223410., 227220., 231030., 234840., 239016., 242832., 246648., 250464.,
      254670., 258492., 262314., 266136., 270372., 274200., 278028., 281856.,
      405645., 411738., 417831., 423924., 430638., 436740., 442842., 448944.,
      455703., 461814., 467925., 474036., 480840., 486960., 493080., 499200.,
      410325., 416490., 422655., 428820., 435606., 441780., 447954., 454128.,
      460959., 467142., 473325., 479508., 486384., 492576., 498768., 504960.,
      415005., 421242., 427479., 433716., 440574., 446820., 453066., 459312.,
      466215., 472470., 478725., 484980., 491928., 498192., 504456., 510720.,
      245298., 249492., 253686., 257880., 262440., 266640., 270840., 275040.,
      279630., 283836., 288042., 292248., 296868., 301080., 305292., 309504.,
      180910., 185260., 189610., 193960., 198580., 202936., 207292., 211648.,
      216298., 220660., 225022., 229384., 234064., 238432., 242800., 247168.,
      182878., 187276., 191674., 196072., 200740., 205144., 209548., 213952.,
      218650., 223060., 227470., 231880., 236608., 241024., 245440., 249856.,
      184846., 189292., 193738., 198184., 202900., 207352., 211804., 216256.,
      221002., 225460., 229918., 234376., 239152., 243616., 248080., 252544.,
      100204., 103192., 106180., 109168., 112304., 115296., 118288., 121280.,
      124436., 127432., 130428., 133424., 136600., 139600., 142600., 145600.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31245.,  31578.,  31911.,  32244.,  33198.,  33540.,  33882.,  34224.,
      35223.,  35574.,  35925.,  36276.,  37320.,  37680.,  38040.,  38400.,
      35925.,  36330.,  36735.,  37140.,  38166.,  38580.,  38994.,  39408.,
      40479.,  40902.,  41325.,  41748.,  42864.,  43296.,  43728.,  44160.,
      40605.,  41082.,  41559.,  42036.,  43134.,  43620.,  44106.,  44592.,
      45735.,  46230.,  46725.,  47220.,  48408.,  48912.,  49416.,  49920.,
      68685.,  69594.,  70503.,  71412.,  72942.,  73860.,  74778.,  75696.,
      77271.,  78198.,  79125.,  80052.,  81672.,  82608.,  83544.,  84480.,
      73365.,  74346.,  75327.,  76308.,  77910.,  78900.,  79890.,  80880.,
      82527.,  83526.,  84525.,  85524.,  87216.,  88224.,  89232.,  90240.,
      78045.,  79098.,  80151.,  81204.,  82878.,  83940.,  85002.,  86064.,
      87783.,  88854.,  89925.,  90996.,  92760.,  93840.,  94920.,  96000.,
      106125., 107610., 109095., 110580., 112686., 114180., 115674., 117168.,
      119319., 120822., 122325., 123828., 126024., 127536., 129048., 130560.,
      110805., 112362., 113919., 115476., 117654., 119220., 120786., 122352.,
      124575., 126150., 127725., 129300., 131568., 133152., 134736., 136320.,
      115485., 117114., 118743., 120372., 122622., 124260., 125898., 127536.,
      129831., 131478., 133125., 134772., 137112., 138768., 140424., 142080.,
      181005., 183642., 186279., 188916., 192174., 194820., 197466., 200112.,
      203415., 206070., 208725., 211380., 214728., 217392., 220056., 222720.,
      185685., 188394., 191103., 193812., 197142., 199860., 202578., 205296.,
      208671., 211398., 214125., 216852., 220272., 223008., 225744., 228480.,
      190365., 193146., 195927., 198708., 202110., 204900., 207690., 210480.,
      213927., 216726., 219525., 222324., 225816., 228624., 231432., 234240.,
      218445., 221658., 224871., 228084., 231918., 235140., 238362., 241584.,
      245463., 248694., 251925., 255156., 259080., 262320., 265560., 268800.,
      223125., 226410., 229695., 232980., 236886., 240180., 243474., 246768.,
      250719., 254022., 257325., 260628., 264624., 267936., 271248., 274560.,
      227805., 231162., 234519., 237876., 241854., 245220., 248586., 251952.,
      255975., 259350., 262725., 266100., 270168., 273552., 276936., 280320.,
      255885., 259674., 263463., 267252., 271662., 275460., 279258., 283056.,
      287511., 291318., 295125., 298932., 303432., 307248., 311064., 314880.,
      260565., 264426., 268287., 272148., 276630., 280500., 284370., 288240.,
      292767., 296646., 300525., 304404., 308976., 312864., 316752., 320640.,
      265245., 269178., 273111., 277044., 281598., 285540., 289482., 293424.,
      298023., 301974., 305925., 309876., 314520., 318480., 322440., 326400.,
      330765., 335706., 340647., 345588., 351150., 356100., 361050., 366000.,
      371607., 376566., 381525., 386484., 392136., 397104., 402072., 407040.,
      335445., 340458., 345471., 350484., 356118., 361140., 366162., 371184.,
      376863., 381894., 386925., 391956., 397680., 402720., 407760., 412800.,
      340125., 345210., 350295., 355380., 361086., 366180., 371274., 376368.,
      382119., 387222., 392325., 397428., 403224., 408336., 413448., 418560.,
      368205., 373722., 379239., 384756., 390894., 396420., 401946., 407472.,
      413655., 419190., 424725., 430260., 436488., 442032., 447576., 453120.,
      372885., 378474., 384063., 389652., 395862., 401460., 407058., 412656.,
      418911., 424518., 430125., 435732., 442032., 447648., 453264., 458880.,
      377565., 383226., 388887., 394548., 400830., 406500., 412170., 417840.,
      424167., 429846., 435525., 441204., 447576., 453264., 458952., 464640.,
      405645., 411738., 417831., 423924., 430638., 436740., 442842., 448944.,
      455703., 461814., 467925., 474036., 480840., 486960., 493080., 499200.,
      410325., 416490., 422655., 428820., 435606., 441780., 447954., 454128.,
      460959., 467142., 473325., 479508., 486384., 492576., 498768., 504960.,
      415005., 421242., 427479., 433716., 440574., 446820., 453066., 459312.,
      466215., 472470., 478725., 484980., 491928., 498192., 504456., 510720.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}